{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-03T01:11:03.023836Z",
     "start_time": "2025-03-03T01:10:57.526189Z"
    }
   },
   "source": [
    "# 导入库\n",
    "import matplotlib as mpl\n",
    "# Matplotlib 绘制的图形会直接嵌入到 Notebook 的输出单元格中，而不是弹出一个独立的窗口\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "\n",
    "# os库提供了一种使用操作系统相关功能的便捷方式，允许与操作系统进行交互\n",
    "import os\n",
    "\n",
    "# sys库主要用于处理Python运行时的环境相关信息以及与解释器的交互\n",
    "import sys\n",
    "import time\n",
    "\n",
    "# tqdm库是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)，即可获得一个进度条显示迭代进度。\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "\n",
    "# torch.nn是PyTorch中用于构建神经网络的模块\n",
    "import torch.nn as nn\n",
    "\n",
    "# torch.nn.functional是PyTorch中包含了神经网络的一些常用函数\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# Python 中的一个属性，用于获取当前 Python 解释器的版本信息。它返回一个命名元组（named tuple）\n",
    "print(sys.version_info)\n",
    "\n",
    "# 遍历模块，打印模块名称和版本信息，快速检查当前环境中安装的某些常用 Python 库的版本信息\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "# 判断是否有 GPU，如果有，则使用 GPU 进行训练，否则使用 CPU 进行训练\n",
    "# torch.cuda.is_available()用于判断是否有GPU\n",
    "# torch.device(\"cuda:0\")创建一个 PyTorch 设备对象，表示使用第一个 GPU（索引为 0）\n",
    "# torch.device(\"cpu\")创建一个 PyTorch 设备对象，表示使用 CPU\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.3.1+cu121\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 数据准备",
   "id": "1c7726b159406172"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:11:04.401332Z",
     "start_time": "2025-03-03T01:11:03.025344Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Path: 用于处理文件路径。\n",
    "from pathlib import Path\n",
    "\n",
    "# 定义数据集的根目录为 ./cifar-10/\n",
    "# 使用 Path 对象处理文件路径\n",
    "DATA_DIR = Path(\"./cifar-10\")\n",
    "\n",
    "train_lables_file = DATA_DIR / \"trainLabels.csv\"  # 训练集标签csv文件\n",
    "test_csv_file = DATA_DIR / \"sampleSubmission.csv\"  #测试集模板csv文件\n",
    "train_folder = DATA_DIR / \"train\"  # 训练集图片文件夹\n",
    "test_folder = DATA_DIR / \"test\"  # 测试集图片文件夹\n",
    "\n",
    "#所有的类别\n",
    "class_names = [\n",
    "    'airplane',\n",
    "    'automobile',\n",
    "    'bird',\n",
    "    'cat',\n",
    "    'deer',\n",
    "    'dog',\n",
    "    'frog',\n",
    "    'horse',\n",
    "    'ship',\n",
    "    'truck',\n",
    "]\n",
    "\n",
    "\n",
    "# 定义一个函数 parse_csv_file，用于解析 CSV 文件并返回图像路径和标签的列表\n",
    "# filepath: CSV 文件的路径。\n",
    "# folder: 图像文件夹的路径\n",
    "# 读取 CSV 文件，解析每一行，生成图像路径和标签的元组列表\n",
    "def parse_csv_file(filepath, folder):\n",
    "    # 初始化一个空列表 results，用于存储解析结果\n",
    "    # 使用列表存储图像路径和标签的元组,方便后续访问和操作解析结果\n",
    "    results = []\n",
    "\n",
    "    # 打开 CSV 文件，读取所有行并跳过第一行（表头）\n",
    "    # 使用 open 函数打开文件，readlines() 读取所有行，[1:] 跳过表头\n",
    "    with open(filepath, 'r') as f:\n",
    "        lines = f.readlines()[1:]\n",
    "\n",
    "    # 遍历每一行数据，去除换行符并按逗号分隔，得到图像 ID 和标签\n",
    "    # 使用 strip('\\n') 去除换行符，split(',') 按逗号分隔,提取图像 ID 和标签\n",
    "    for line in lines:\n",
    "        image_id, label_str = line.strip('\\n').split(',')\n",
    "\n",
    "        # 拼接图像文件的完整路径\n",
    "        # 使用 Path 对象拼接路径，f\"{image_id}.png\" 生成图像文件名\n",
    "        image_full_path = folder / f\"{image_id}.png\"\n",
    "\n",
    "        # 将图像路径和标签的元组添加到 results 列表中\n",
    "        results.append((image_full_path, label_str))\n",
    "    return results\n",
    "\n",
    "\n",
    "#  调用 parse_csv_file 函数，解析训练集和测试集的 CSV 文件\n",
    "train_labels_info = parse_csv_file(train_lables_file, train_folder)\n",
    "test_csv_info = parse_csv_file(test_csv_file, test_folder)\n",
    "\n"
   ],
   "id": "90c122b759376c7d",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:11:04.444152Z",
     "start_time": "2025-03-03T01:11:04.403337Z"
    }
   },
   "cell_type": "code",
   "source": [
    "train_df = pd.DataFrame(train_labels_info[0:45000])  # 取前45000张图片作为训练集\n",
    "valid_df = pd.DataFrame(train_labels_info[45000:])  # 取后5000张图片作为验证集\n",
    "test_df = pd.DataFrame(test_csv_info)  # 取测试集\n",
    "\n",
    "train_df.columns = ['filepath', 'class']  # 给数据框添加列名\n",
    "valid_df.columns = ['filepath', 'class']\n",
    "test_df.columns = ['filepath', 'class']  # 数据准备"
   ],
   "id": "6645a850d398f99a",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:11:05.799935Z",
     "start_time": "2025-03-03T01:11:04.445157Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# PIL（Python Imaging Library）用于图像处理，Image 模块可以加载和操作图像\n",
    "from PIL import Image\n",
    "\n",
    "# Dataset 是 PyTorch 中用于定义数据集的基类\n",
    "# DataLoader 用于批量加载数据，支持多线程和数据打乱\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "# transforms 提供了图像预处理和数据增强的工具，如调整大小、旋转、归一化等\n",
    "from torchvision import transforms\n",
    "\n",
    "\n",
    "# 定义一个自定义数据集类，继承自 PyTorch 的 Dataset 类\n",
    "# CIFAR-10 数据集的加载方式与默认数据集不同，需要自定义\n",
    "class Cifar10Dataset(Dataset):\n",
    "    # 定义一个字典，将数据集模式（train/eval/test）映射到对应的数据框\n",
    "    # 通过 mode 参数快速获取对应的数据集\n",
    "    df_map = {\n",
    "        \"train\": train_df,\n",
    "        \"eval\": valid_df,\n",
    "        \"test\": test_df\n",
    "    }\n",
    "\n",
    "    # 创建一个字典，将类别名称映射到索引（如 \"cat\" -> 0）\n",
    "    # 使用字典推导式生成映射关系\n",
    "    # 模型需要数值标签，而数据通常以类别名称存储，因此需要转换\n",
    "    label_to_idx = {label: idx for idx, label in enumerate(class_names)}\n",
    "\n",
    "    # 创建一个字典，将索引映射回类别名称（如 0 -> \"cat\"）\n",
    "    # 与 label_to_idx 类似，但方向相反\n",
    "    # 在模型预测后，可能需要将索引转换回类别名称以便解释结果\n",
    "    idx_to_label = {idx: label for idx, label in enumerate(class_names)}\n",
    "\n",
    "    # 初始化 Cifar10Dataset 类的实例\n",
    "    # mode：指定数据集模式（train/eval/test）。\n",
    "    # transform：指定图像预处理和数据增强的方法\n",
    "    def __init__(self, mode, transform=None):\n",
    "        # 根据 mode 获取对应的数据框\n",
    "        # 使用字典的 get 方法获取值，如果 mode 不存在则返回 None\n",
    "        self.df = self.df_map.get(mode, None)\n",
    "\n",
    "        # 检查 mode 是否有效，如果无效则抛出错误\n",
    "        # 防止因无效模式导致后续代码出错\n",
    "        if self.df is None:\n",
    "            raise ValueError(\"mode should be one of train, val, test, but got {}\".format(mode))\n",
    "\n",
    "        # 保存 transform 参数到对象属性中\n",
    "        # 在 __getitem__ 方法中会用到 transform\n",
    "        self.transform = transform\n",
    "\n",
    "    # 根据索引获取单个样本（图像和标签）\n",
    "    # Dataset 类的核心方法，定义了如何获取数据,DataLoader 会调用此方法批量加载数据\n",
    "    def __getitem__(self, index):\n",
    "        # 从数据框中获取图像路径和标签\n",
    "        # 使用 iloc 方法按索引获取数据,数据框存储了图像路径和标签，需要按索引提取\n",
    "        img_path, label = self.df.iloc[index]\n",
    "\n",
    "        # 加载图像并转换为 RGB 格式\n",
    "        # Image.open 加载图像，convert('RGB') 确保图像为三通道\n",
    "        img = Image.open(img_path).convert('RGB')\n",
    "\n",
    "        # 对图像应用预处理和数据增强\n",
    "        img = self.transform(img)\n",
    "\n",
    "        # 将类别名称转换为索引,使用 label_to_idx 字典进行转换\n",
    "        label = self.label_to_idx[label]\n",
    "        return img, label\n",
    "\n",
    "    def __len__(self):\n",
    "        # 返回数据框的行数，即样本数量\n",
    "        # shape[0] 获取数据框的行数\n",
    "        return self.df.shape[0]\n",
    "\n",
    "\n",
    "# 定义图像的输入大小\n",
    "IMAGE_SIZE = 32\n",
    "mean, std = [0.4368, 0.4268, 0.3947], [0.2464, 0.2418, 0.2358]\n",
    "\n",
    "# 定义训练数据的预处理和数据增强方法\n",
    "# 数据增强（如旋转、翻转）可以提高模型的泛化能力，避免过拟合\n",
    "# 训练时需要增加数据的多样性，同时确保输入数据符合模型的期望格式\n",
    "transforms_train = transforms.Compose([\n",
    "    transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),  # 将图像调整为指定大小（32x32）\n",
    "    transforms.RandomRotation(40),  # 随机旋转图像，最大角度为40度\n",
    "    transforms.RandomHorizontalFlip(),  # 随机水平翻转图像\n",
    "    transforms.ToTensor(),  # 将图像转换为PyTorch张量（Tensor），并将像素值从 [0, 255] 归一化到 [0, 1]。\n",
    "    transforms.Normalize(mean, std)  # 根据均值和标准差对图像进行归一化\n",
    "])\n",
    "\n",
    "# 验证/测试数据不需要数据增强，只需进行基本的预处理\n",
    "# 验证/测试时，需要保持数据的原始分布，以评估模型的真实性能\n",
    "transforms_eval = transforms.Compose([\n",
    "    transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),  # 将图像调整为指定大小（32x32）\n",
    "    transforms.ToTensor(),  # 将图像转换为PyTorch张量（Tensor），并将像素值从 [0, 255] 归一化到 [0, 1]。\n",
    "    transforms.Normalize(mean, std)  # 根据均值和标准差对图像进行归一化\n",
    "])\n",
    "\n",
    "# 创建训练数据集对象\n",
    "train_ds = Cifar10Dataset(\"train\", transforms_train)\n",
    "eval_ds = Cifar10Dataset(\"eval\", transforms_eval)"
   ],
   "id": "4281fa1e2fda6170",
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:11:05.804154Z",
     "start_time": "2025-03-03T01:11:05.800942Z"
    }
   },
   "cell_type": "code",
   "source": [
    "batch_size = 64\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n",
    "eval_dl = DataLoader(eval_ds, batch_size=batch_size, shuffle=False)"
   ],
   "id": "ee481a25632cfb34",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:11:53.718089Z",
     "start_time": "2025-03-03T01:11:05.805160Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "# 经过 normalize 后 均值为0，方差为1\n",
    "print(cal_mean_std(train_ds))"
   ],
   "id": "d98e20ef6518256",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([ 0.0002, -0.0003, -0.0004]), tensor([0.9999, 1.0000, 1.0004]))\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型定义",
   "id": "41d8a16f3e2af73c"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:11:53.725588Z",
     "start_time": "2025-03-03T01:11:53.718594Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class VGG(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=\"same\"),  # 32*32*32\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),  # 32*32*32\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),  # 32*16*16\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),  # 32*16*16\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),  # 32*8*8\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),  # 32*8*8\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),  # 32*4*4\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(512, num_classes),\n",
    "        )\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "\n",
    "\n",
    "for key, value in VGG(len(class_names)).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n"
   ],
   "id": "e25c809364c4ce2e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             model.0.weight             paramerters num: 864\n",
      "              model.0.bias              paramerters num: 32\n",
      "             model.2.weight             paramerters num: 9216\n",
      "              model.2.bias              paramerters num: 32\n",
      "             model.5.weight             paramerters num: 9216\n",
      "              model.5.bias              paramerters num: 32\n",
      "             model.7.weight             paramerters num: 9216\n",
      "              model.7.bias              paramerters num: 32\n",
      "            model.10.weight             paramerters num: 9216\n",
      "             model.10.bias              paramerters num: 32\n",
      "            model.12.weight             paramerters num: 9216\n",
      "             model.12.bias              paramerters num: 32\n",
      "            model.16.weight             paramerters num: 5120\n",
      "             model.16.bias              paramerters num: 10\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "972132766f417251"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:12:34.777606Z",
     "start_time": "2025-03-03T01:12:34.770540Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#模型总参数量\n",
    "total_params = sum(p.numel() for p in VGG(len(class_names)).parameters() if p.requires_grad)\n",
    "print(f\"Total trainable parameters: {total_params}\")"
   ],
   "id": "6d18a5f2e70184d9",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total trainable parameters: 52266\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:12:48.362874Z",
     "start_time": "2025-03-03T01:12:48.251257Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        preds = logits.argmax(axis=-1)  # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "id": "72f532c47c4b036e",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:12:59.525217Z",
     "start_time": "2025-03-03T01:12:55.267848Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "\n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\",\n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "        )\n",
    "\n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "\n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "\n",
    "        )\n",
    "\n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "id": "75260f2f30a9a074",
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:13:49.185524Z",
     "start_time": "2025-03-03T01:13:49.180048Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 SaveCheckpointsCallback 的类。\n",
    "# 该类用于在训练过程中保存模型的检查点。封装保存检查点的逻辑，方便在训练过程中调用\n",
    "class SaveCheckpointsCallback:\n",
    "    \"\"\"\n",
    "    Callback to save model checkpoints during training.\n",
    "    \"\"\"\n",
    "\n",
    "    #定义类的构造函数，接受以下参数：\n",
    "    # save_dir: 检查点保存的目录。\n",
    "    # save_step: 每隔多少步保存一次检查点，默认值为 500。\n",
    "    # save_best_only: 是否只保存性能最好的检查点，默认值为 True\n",
    "    # 原理：初始化回调类的参数和状态\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "\n",
    "        # 初始化一个变量 best_metrics，用于记录当前最好的性能指标值，初始值为 -1\n",
    "        # 原理: 用于比较当前模型的性能是否优于之前保存的模型,当 save_best_only 为 True 时，只保存性能最好的模型\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # 检查保存目录是否存在，如果不存在则创建该目录\n",
    "        # os.path.exists()用于判断路径是否存在, os.mkdir()用于创建目录\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    # 定义 __call__ 方法，使类的实例可以像函数一样调用。参数包括：\n",
    "    # step: 当前训练的步数。\n",
    "    # state_dict: 模型的状态字典（包含模型参数）。\n",
    "    # metric: 当前模型的性能指标值（如验证集准确率），默认为 None\n",
    "    # 在训练过程中定期调用该方法，保存检查点\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "\n",
    "        # 检查当前步数是否是 save_step 的倍数，如果不是则直接返回\n",
    "        # 控制保存检查点的频率，避免频繁保存\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        # 检查是否只保存性能最好的检查点\n",
    "        # 根据 save_best_only 的值决定保存策略,提供两种保存策略：定期保存和只保存最佳模型\n",
    "        if self.save_best_only:\n",
    "\n",
    "            # 如果 save_best_only 为 True，则要求 metric 不能为 None。\n",
    "            # 原理: 使用 assert 断言确保 metric 有值。如果 metric 为 None，无法判断模型性能是否更好，因此需要提前检查\n",
    "            assert metric is not None\n",
    "\n",
    "            # 检查当前模型的性能指标是否优于之前保存的最佳模型\n",
    "            # 只保存性能更好的模型，避免保存性能下降的模型\n",
    "            if metric >= self.best_metrics:\n",
    "                # 将模型的状态字典保存到指定目录下的 best.ckpt 文件中\n",
    "                # 使用 torch.save 保存模型参数。保存当前性能最好的模型，方便后续加载和使用\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "\n",
    "                # 更新 best_metrics 为当前模型的性能指标值\n",
    "                self.best_metrics = metric\n",
    "\n",
    "        # 如果 save_best_only 为 False，则执行以下逻辑\n",
    "        # 定期保存检查点，不关心模型性能是否更好\n",
    "        else:\n",
    "\n",
    "            # 将模型的状态字典保存到指定目录下，文件名为当前步数\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))"
   ],
   "id": "dd045e779b42a56e",
   "outputs": [],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:14:30.457288Z",
     "start_time": "2025-03-03T01:14:30.451083Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else:\n",
    "            self.counter += 1\n",
    "\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "8d219ab0d64e63f3",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T01:23:28.898081Z",
     "start_time": "2025-03-03T01:15:05.805894Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n",
    "\n",
    "\n",
    "epoch = 10\n",
    "\n",
    "model = VGG(num_classes=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "#可以修改adam里边的weight_decay参数，来控制L2正则化的程度,beta1和beta2是指数衰减率\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/vgg\")\n",
    "tensorboard_callback.draw_model(model, [1, 3, IMAGE_SIZE, IMAGE_SIZE])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/vgg\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_dl,\n",
    "    eval_dl,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    ")"
   ],
   "id": "38a53f0db4914943",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/7040 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "bcd0af6275c643828cb6264578210e75"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-03T04:10:13.646290Z",
     "start_time": "2025-03-03T04:10:13.455847Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=100)  #横坐标是 steps"
   ],
   "id": "960a71681d3744c7",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzwAAAHFCAYAAAA39PwWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA979JREFUeJzsnQeYVOX1xt9p23tnl4Wl9yYKIhZEimKJiVETC4aoiRqNicZ/NAVFo0aTmGaLLZpYYu+IIIiAokhTytIXlrK996n/53z3ftN2+s7O7uyc3/MMU+/MN7PLzn3ve857NDabzQaGYRiGYRiGYZgBiLavF8AwDMMwDMMwDNNbsOBhGIZhGIZhGGbAwoKHYRiGYRiGYZgBCwsehmEYhmEYhmEGLCx4GIZhGIZhGIYZsLDgYRiGYRiGYRhmwMKCh2EYhmEYhmGYAQsLHoZhGIZhGIZhBiwseBiGYRiGYRiGGbCw4GEYhmEYhmEYZsDCgodhGIYZEDz22GMoKSlBQkICZs6ciU2bNvl8/N/+9jeMGTMGiYmJKC4uxi9/+Ut0dnZGbL0MwzBMZGDBwzAMw0Q9r776Km677Tbcfffd2Lp1K6ZMmYKFCxeiurra4+Nffvll3HnnneLxpaWlePbZZ8Vz/OY3v4n42hmGYZjeRWOz2Wy9/BoMwzAM06uQo3PKKafg0UcfFdetVqtwbW655RYhbNy5+eabhdBZvXq1/bbbb78dX331FTZs2BDRtTMMwzC9ix5RAH1xnThxAqmpqdBoNH29HIZhmJiBjom1tLSgsLAQWm3/LAowGo3YsmUL7rrrLvtttNZ58+Zh48aNHrc57bTT8OKLL4qytxkzZuDQoUNYvnw5rr76aq+v09XVJU7O30319fXIzs7m7yaGYZh+/N0UFYKHxA4dqWMYhmH6hqNHj2Lw4MHoj9TW1sJisSA/P9/ldrq+Z88ej9tcccUVYrvTTz9dfHGazWbccMMNPkvaHnzwQSxbtizs62cYhmF697spKgQPOTvyTaWlpQW9vclkwsqVK7FgwQIYDAZEC9G47mhcM8HrjizRuO5oXHM41t3c3CwOOMm/wwOFtWvX4oEHHsDjjz8uyuEOHDiAW2+9Fffddx9+//vfe9yGHCTqE5I0NTVhyJAhKCsrC+nzoZ/Np59+irPPPjtqfqeicc0ErzuyROO6o3HNsbzulpYWDBs2LOC/vVEheGSpAImdUAVPUlKS2Dbafhmibd3RuGaC1x1ZonHd0bjmcK67P5ds5eTkQKfToaqqyuV2ul5QUOBxGxI1VL523XXXieuTJk1CW1sbfvKTn+C3v/2txxKJ+Ph4cXInKyurR99NVBIXLb9T0bhmgtcdWaJx3dG45lhet0HdJtDvpv5ZkM0wDMMwARIXF4fp06e7BBBQfw1dnzVrlsdt2tvbu4kaEk0EZ/kwDMMMLKLC4WEYhmEYX1Cp2TXXXIOTTz5ZhBDQjB1ybJYsWSLuX7x4MYqKikQfDnHhhRfikUcewbRp0+wlbeT60O1S+DAMwzADAxY8DMMwTNRz+eWXo6amBkuXLkVlZSWmTp2KFStW2IMMysvLXRyd3/3ud6IUgs6PHz+O3NxcIXbuv//+PnwXDMMwTG/AgodhmJCR6VaUkBVs7a5erxdT7YPdtq+IxjUHsm5yM+j+/tyjEyg0W4dO3kIKnKH3TENH6cQwDMMMbFjwMAwT8uyTiooK0QsRilCiZnJKXoyWHe1oXHOg66bG0UGDBoleGIZhGIYZaLDgYRgmaKghnKJ4yR2goV+0oxyMCKDtW1tbkZKS0m+HWQ6ENftbN4khEq5UCkY/z1GjRkXVe2MYhmGYQGDBwzBM0NBOMu1I03wWcgeChbal50hISIiaHexoXHMg605MTBTxnkeOHLE/jmEYhmEGEtHzrc0wTL8jmnb8Ge/wz5FhGIYZyPC3HMMwDMMwDMMwAxYWPAzDMAzDMAzDDFhY8DAMw4RISUmJGHAZDig2mYIfGhsbw/J8DMMwDMMocGgBwzAxxZw5c8RQynAIla+//hrJyclhWRfDMAzDML0DCx6GYRi3qGYa0EmDKf2Rm5sbkTUxDMMwDBM6A76k7fCebVj78GWI++bZvl4Kwwx4odBuNAd86jBagnq8txO9bqD86Ec/wmeffYa///3vonyMTs8//7w4/+ijjzB9+nTEx8djw4YNOHjwIL7zne8gPz9fzLCZOXOmKDvzVdJGz/PMM8/gu9/9rojrprk27733Xsif6ZtvvokJEyaINdFr/eUvf3G5//HHHxevQVHStM7vf//79vveeOMNTJo0SThQw4cPx4IFC9DW1hbyWhiGYZjQeGVTOa7/z2Z0mix9vZSYZcA7PFazEfNNa9BsS6I9sr5eDsMMWDpMFoxf+nHEX3f3vQuRFBfYnzISOvv27cPEiRNx7733itt27dolzu+88078+c9/FuIgMzMTR48exaJFi3D//fcLwfHCCy/ghz/8IUpLS4X48MayZcvw8MMP409/+hP++c9/4sorrxQzbrKysoJ6X1u2bMFll12Ge+65B5dffjm++OIL3HTTTcjOzhbCbfPmzfj5z3+O//73vzjttNNQX1+P9evXi20rKirEWmkdJNro+vbt24MShwzDMEx4eHztARyt78AXB2sxd2x+Xy8nJhnwggc5I2G2aZGmaYeppRLIHtLXK2IYpo9IT09HXFyccF8KCgrEbXv27BHnJIDmz59vfywJlClTptiv0/3kuLz//vu45ZZbvL4GiRESG8QDDzyAf/zjH9i0aRPOPffcoNb6yCOP4JxzzsHvf/97cX306NHYvXu3EFL0GuXl5cK9ueCCC5CamoqhQ4di2rRp4rEkcMxmM773ve+J4bD0XmbNmsXzdhiGYSIMHWiqau4Sl483dvb1cmKWAS944hOSUGYbhFGa49DU7mHBwzC9RKJBJ9yWQLBarWhpbkFqWmqPd8LpdcPBySef7HK9tbVVuCsffvihXUB0dHQIoeGLyZMn2y+TIElLS0N1dXXQ6yEnidwZZ2bPni1K6KjHiMQZiRxypEhM0UmW0pFQI7FEJW1UynbGGWfgqquuEu4QwzAMEzmaO8wwmq3i8onGjr5eTswy4A/3xem02GcrUq5Ul/b1chhmwEL9K1RaFugpMU4X1OO9neh1w4F72tqvfvUrvP3228KloVKxrVu3Yvz48TAajT6fx2AwdPtcSOCFG3J1aE2vvPIKBg0ahKVLlwqhQ7HWOp0Oq1atEn1JtOannnoK48aNQ1lZWdjXwTAMw3inusXh6rDg6TsGvOCJN2ix3zZYXLax4GGYmIdK2sgh8cfnn38uSsfINSGnhErg/Lk74YQECq3BfU1U2kaChqAkuXnz5olenW+//RaHDx/GmjVr7EKLHCFyqdatWyfeNwk4hmEYJnJUtyjlbAQLnr5j4Je06bXYay1WrtQotfoMw8QuFDjw1VdfCXFA6Wve3BdKP3vrrbdw4YUXCvHwu9/9LqJN/7fffjtOOeUU3HfffSK0YOPGjXj00UdFMhvxwQcf4NChQzjzzDNFyMLy5cvFexkzZox4f6tXrxblbDk5OSJdrqamRogohmEYpq8cHu7h6StipKRNcXh0dfs4qY1hYhwqVSOHhEq9aI6ON9eGQgNISFACGomehQsXuvTn9DYnnXQSXnvtNfzvf/8TqXJUskbBCeQ6ERkZGUKQzZ07VwiZJ598UpS3UYw19Q2Rq0Mpc2PHjhVJc5RAd95550Vs/QzDMAxQrQYWEJXNnTBbelbibLXyfmwoDHiHh47MVugGocumR7ypDWg6CmRwcAHDxCpUEkZuiTNSRLg7QbI8jCD3hBr/SUxIyCVyxpMDRD01gTBnzpxu219yySXi5InTTz+921wgCQmgFStW2Nfd3Nzssm6GYRgm8iVtFqtNXC/MSAzpuT7ZXYVfvrodf7p0Ms6dOCiMqxz4DHiHh9Dp43DIpv5icB8PwzAMwzAME2HB09M+ng0HatHSZca6/bVhWFlsEROCh/p4ZHABCx6GYfqCG264QfQMeTrRfQzDMMzAo7rZtW/neA8ET1OHSZw3tvtOC2VisKRN9vGI4ALdRg4uYBimT6D+G+of8gSXmzEMwwxMalSHpzA9ASeaOsMkeJRzJnD0sePwyFk8u/t6OQzDxCB5eXnixDAMw8ReSdu0IZk4saOiRyVtUvA0sOAJmpgpaZNJbajZB1j9z+BgGIZhGIZhmFBpN5rR2mUWl6cWZ/Q4mrqZS9pCJiYET5xBi3JbPizaeMDcATS4JisxDMMwDMMwTG9EUicadBiVnyIuh8fhYcETLLEheHRaWKFFS+pw5Qbu42EYhmEYhmF6kSo1sCA/LR6DM5Uo6nD08HSarOg0RU+1UofRgrLatj5dQ0wInni9Tpw3poxQbuCkNoZhGIZhGCYC/Tt5qQkYlK4InpZOM5o7g+/BIYHTZXYMLY2m4ILbXtuOs/+8FrtONPXZGmJE8ChvsyGJBQ/DMAzDMAwTOcGTmxaP5Hg9MpIM4npFCH087iIpmsraNh9pEOd7K1v6bA0xIXjiVMFTmzRMuYFL2hiGCZHhw4fjb3/7W0CP1Wg0eOedd3p9TQzDMEz/o7pFETZ5qfHivFB1eULp45GBBdEmeFq7zPZo7rrWvltzTDk8VQlqD0/tPsCipGYwDMMwDMMwTLipaXaUtBGFGaH38cj+nWgraTvs1LtT18aCJyKCp06XBxiSAYsRqD/U18tiGIZhGIZhBnwPj+LwFGUk9MDhMUelw3PIWfC0Kp9Hvxc8Dz74IE455RSkpqaKAXoXX3wx9u7d63Obp59+GmeccQYyMzPFad68edi0aRP6QvB0UaBF3ljlxhru42GYsGKzAca2wE+m9uAe7+1ErxsgTz31FAoLC2G1Oho/ie985zv48Y9/jIMHD4rL+fn5SElJEX/vPvnkk7B9RDt27MDcuXORmJiI7Oxs/OQnP0Fra6v9/rVr12LGjBlITk5GRkYGZs+ejSNHjoj7vvnmG5x99tni729aWhqmT5+OzZs3h21tDMMwTC+VtKWpJW0x7vDU96HDow/mwZ999hl+9rOfiZ0As9mM3/zmN1iwYAF2794tvqA9QV/gP/zhD3HaaachISEBDz30kNhm165dKCoqQiR7eLrMFiB3HHB8ixJcMP47EXl9hokJSMA8UBjQQ+l/pDKCLQz85gQQ5/nvjzuXXnopbrnlFnz66ac455xzxG319fVYsWIFli9fLsTHokWLcP/99yM+Ph7/+c9/cOGFF4oDO4MHq8OLQ6StrQ0LFy7ErFmz8PXXX6O6uhrXXXcdbr75Zjz//PPibyodRLr++uvxyiuvwGg0ioND1AdEXHnllZg2bRqeeOIJ6HQ6bN++HQaD0gDLMAzD9O+UNqJIjaY+ERbB00PxYLMBVTuBA58AoxYC+ePRGzjHUddGi+ChnQJn6EuanJ4tW7bgzDPP9LjNSy+95HL9mWeewZtvvonVq1dj8eLFiKTgMVKcX77q8HBSG8PEHOQyn3feeXj55ZftgueNN95ATk6OcE+0Wi2mTJlif/x9992Ht99+G++99x5uuummHr02vWZnZ6cQUfIA0aOPPioEFR0IIvHS1NSECy64ACNGKImS48aNs29fXl6OO+64A2PHKn/DRo0a1aP1MAzDMMHR0GbEa5uPKvuTTkwoSsPcsfkut9FBdunC2EMLVIfnRAgpbe6CpyEUh6etFjj4KXBwNXBwDdBapdxu6uw1weNc0lbf1hUdgscd+nImsrKyAt6mvb0dJpPJ5zZdXV3iJGlubhbntB2dgsWgHCBFp8kMc9Zo8aZt1bthDuG5Iol8r6G8574iGtdM8LqDf12bzSZKw+zlYboE4M5jAW1P27a0tiI1JcXuYIQMva5biZovyHH+6U9/KsQGuTh0UObyyy+3/61ZtmyZcHsqKiqE69LR0SHKymjNzut3L4vzhvyMyAknMUXlbHJbcnvocmlpqThodM011wgXiEp/6USO1KBBg8Rjf/nLXwpH6L///a8Qa9///vftwsgXct2+1ky30/30cyX3yJlo+z/BMAzTW9zxxjf4pLS62+1aDbDxrnOQn6Y4OYRMJovTae1x1EWq4Kls7oTZYoVepw06pS01QS9m+QTk8FhMwLGvgQMkcFYDJ7bTt4HjfkMSUHJGr4kd+l4pq3GUbfdlSlvIgoe+IH/xi1+IGvOJEycGvN2vf/1rUUNPX+a+eoVop8OdlStXIikpKei1Hj5OO1Q6HC4/jtWaWiykH0LtQXz0wXuwaXuk+SLCqlWrEG1E45oJXndg6PV6FBQUiBIwKr0KCUMSWroCFype6Qwu1/+ss84Sf7/I2aESsfXr1+Pee+8VYodEBZXhkrMzbNgwIU5IhND7bGlRXoe2JadGHojxBwkmeix9TiSgnLeTl6ncjS5T3DX1ElHfEDlCv//97/HWW2+JMmJaG7lB9HeQft733HMPnn32WeEIBYJcvydobbTOdevWiTW6H6RiGIaJdT7dWy3Ejl6rwfenD7YfrFu1uwq1rV349lgT5o9P6D6DJzXe/tjclHgYdBqYLDZxv3R8gnF4SrKTseN4k3eHp+GIIm5I5JStA7rcvqvyJwIj5gIj5wFDTgX0ivvUG9Aamzsd3yntRgs6jBYkxrkeWIsEIe/tUy/Pzp07sWHDhoC3+eMf/4j//e9/YoeC+nm8cdddd+G2226zX6cdgeLiYtH7Q826wVL1eRneK9+PrLx8zP3OQtgO/B7arhacN2MUkOcoGelv0JFV2rGZP39+1NTqR+OaCV53cNAO/9GjR0Vjv6//yz4dnpYW0YDfY4cnSOhvyPe+9z1RqnbixAmMGTNGBKsQFAKwZMkSXHHFFeI6CR16n3FxcWKttGYqe6P3HOjfIhJN9NjJkyeL3hxyUGRJG/39pOc76aST7M93+umnixMJGjqgROV0svyOHkenO++8U6zx1Vdfta+1J581/TxpneQyuf88AxV2DMMwAxUqYbv3/d3i8o9OK8HvLnA4IiaLFW9sOYadx0nwOMraqmUktRpYQGi1GhSkJ+BofYfo4wlF8AzJTlIFj3qw0diGvKZvoP14PVD2KVB3wHXDxCxV4JyjnKcWIFKU1SruTmF6AmpbjTBarKhr68LguODNiz4RPNRk+8EHH4ijgYE28v75z38WgoeOXNIXvy+ozIRO7tAOXSg7dUnxyjZUcmmIiwPyxgNHv4Khfh9Q5Hst/YFQ33dfEo1rJnjdgWGxWMTOM+2s0ylYZGmVfI5Ic9VVVwlnhMrM6LJcA/XFkBC66KKLxNrIYaG10mVnsRDMuuVndPXVVwvnmgQViZmamhrceuut4nYqWysrKxMpcvTa5IJTUML+/ftFryOV+FL/DpWxkfN07NgxIc4uueQSv+sI5LOm2+l+T79H0fj/gWEYJpw893mZaL7PSYnHrfNc+ycnFqbhjS0QgseZGrehoxIaPkqCh5LaTg5iDc2dqsOTlYgxmnKc17oLeOER6Ms3YhaNW5HTVjQ6oHgGMOIcYORcYNBUQBt5R4Uoq1UqBIblJotCuoqmTpHUNjiznwseOlJICUe0Q0AuDX3xBsLDDz8sUo8+/vhjnHxyMD/eMMdSyyaz3LFC8KBmT8TXwjBM30PR0NRHSKLC2SF55JFHREkZpUpSkAGV4IbL4aByXPobSCKHStToOgkWek15/549e/DCCy+grq5OiCBy0qnfiMrM6DYSP1VVVWJt5FJ5Kv1lGIZhwkdVcyf+uXq/uPzrc8cgNcH1INDEonRxvvNEk8+ENklRKMEF7fWY2rQal+i/wvnb9uCO+GqlFacMoENx7XE5iJ+wCLpR84HhZwEJypr6mjLV4RmWkywCHEjw9FUfT1CCh758qa783XffFeURlZWV4vb09HRRDkHQFzLFTVMfDkHpQ0uXLhXblZSU2LehUhg6RQJqGHMRPOTwEJzUxjAxCTkaVM7mDv2NWrNmTbe/e85OyaFDhwJ2d5yDDohJkyZ1e34Jzf6hg0meoJI6KodjGIZhIssfP9qDNqMFU4szcMlJ3auaxg1KAxUAVDV3ibk7UuCQUPLo8GQEEE1tMQPHNzvCBo5vxZ2kcGivvQvosMXhS+s4nLrgMuhHzcWqL/dh0aLzoetnjnyZmtBGfUfl9cr7reujaOqgaklo/gMls82ZM0ccfZQnqiN3jk6ldCPnbaghlkoxnLehErfIOzw0edRp+CgLHoZhmAHDY489JkQr9SHNnDnT55Br+h6TpYrOp/PPPz+ia2YYpv+y+XA93t52XAiaZRdNED047iTH6zE8R+nL3HWiubvD49TD41PwNB4FtjwPvHo18PBw4LmFwLqHldmRsGGfrRj/Mp+PiotewanWZ7HE9GtUj18CZI+immX0R8rUkrbhucnITo4Tl+ta+yaaOuiSNn9QqZszhw8fRl8TZ5BzeNT10/BRoqEMMHUAhsCbxhiGYQiKs6ZyM08MHTpUDFdmIgcdeKOwmyeffFKIHUq8o4hvKlukeXHuUPqdc8IglQxSbDhFgTMDj9c2H8NLpVq8VbcVWnXnkCKBf3LmcJxSEvhojYFCu9GM+z4oxfmTBuH0UTle9/ke/GgPxg1KxXen9WzwcjRitdpwz/vK3/HLphdjSrH3cdmTitJxsKYNu4434ewxea6hBW4lbYUZCdDCqoQL7DoGHN2kDP+s3ef6pImZwPCzRdiAuWQOFjz0jbj5+6PPQXLSBjQ1dYoUtMI0RUgEg9lixZ9X7sO0IRlYOKF3Qgzo9+ewk8MjBQ/18PQF/T+TOYwlbUbp8KTkKakVHfXKL9ggx6BBhmGYQKBwAdqx9gQ3+kce6oW6/vrrRSgEQcLnww8/xHPPPSdS7dxxnwVHCaLUR8WCZ+BBO173frgHXWYt0Fjrcl+nyYL/Xuv5//FAZsXOSryyqRwHqlu8Cp7dFc14at0hsaMai4LnSH07dh5vFsPr7zh3jM/HUh/PO9tPiPQ0d4cnP74LOPIFULULqNyBU499g53xpUii+193PIcFWmyzjoR+1DmYevb3gcJp9rCBFieRkJZoQHpSHE40daqzeBR3KRhW7a7Ck58dRHqiAeeMzQtqHlCgUIlfh8kCnVaD4qwkZKUogofS2vqCmBA83UIL6OgOxVEf+Ryo3sOCh2GYoKE+RjoxfQ85NVu2bBEjDSTUZ0Xz3jZu3BjQc9BMox/84Af2yPBIDMWOxoHH0bhmOqIsv//vu3AsDHodjtS144l1ZTjeoAxDj7XPe39Vs92F8PbcFQ1t9p6L1o4u+77UQP09cV+zfP8FafFIj9f6fC9j85OhgRUNR/fAvKMctoodeLDrM4yNK0fxCzUujxV+jwbotBmgHzQBmkGT8XbTaNy7Ow/NSMEN2cMwIX8UYLEqJ/oZtCjlb0k0v8ZqQUaisvte29IZ0me9anelPep606FanFKSiXCzv1IRf8WZicqaE9Q1typr7unvSLDbxYjg0dlz1O1QUhsJnhru42GYUAmkzJXp/0T7z7G2tlZEpVPwgzN0nZLv/EG9PjRXjkSPL8I9FDuaBx5H05pPiP1WPZL1NqTV7hS35Yh+cj2O1rfhww+X99cWiF77vDfuI/GiRXVTG5YvX+7xMZtqlKHtxOvvr0BW/MD+PXFf8zd1yvvXGtu7fUZ6SwfSOo4iraNcnI9tL8fO+GNINnYBbyqPme+UBN1uyEJzYjGaE4egKXEI7jlQglLzINyRboWuA3ioVAeLyFsDtpYexHKTkgonOSLCzvSIg1mspaNJ+fl9sXk7DMdtQX3WVhuwcictTnm9Zz/6CjVDwzAE3I3Pq5TPL8nSKtZcVq9cP3S8xuXzDPV3JNih2LHp8BBy4CgHFzBM0MiSLfqDIxMamehFfnHEaikeCR1K0JsxY4bPx4V7KHY0DjyOxjWvP1ALfLsVaQbY1037A/dt+wQmqwanzpln7y+Ilc/7iTJyPlvQYdHgnAXnenRvTmw4DBxQ+komnHwapvnoYYnUunsT9zU3bjoKzb5dODXfgvOHA5rqndBU7YKmejc0jR760zVAl80AY9ZoGHPG45+7E1GVMAL/uPUKGBIzkQ2IE2F9bCOslS0YMWk6XvyqHBZbnXBv2o0WxKfnYtGi6S5PveFAHbBjC/IzU7Fo0Wn40rwb2+uOobBkFOafOTSoz/rbY01o/fIr+/VyMz3n7J5/gO6vs2IvcOgIZowrwaJFY1F4tBFP790Eiz4Rixad2ePfkWBHRsSE4KH6S4IFD8OEB51Oh4yMDFRXV4vrdHTbeTCnPyjimcqQOjs7+2TwaChE45r9rZucHRI79HOknyf9XKMRmktEa6cZRc7Q9YIC3w25bW1ton/n3nvv9fs64R6KHa7t+4JoWnN9u9K/mx5ns6+blk5xwdRnUdNqRkFG8H0Q0fp50/97KumTtBptSEns/tyNnWaXzzCU14+m3xN0tSCzbT/iv62CrrYU8/dtxiXx+5ByvNPu2riQWggUTATy6TQB927W4YW9OvxqygSMzk/B8zs2Y1JGOgxp3UNTijKTUFrZgle+PoZ1++tg0GnwfwvH4J73d6Om1djtM2szKfuv1LtD92WnKEEIzV2On0ugn/VnB+rF+eyR2dh4sA77q9tQ1WoK+zDQI2oM9Yj8NLGu/HTl/1h9uxF6vb7HvyPBbhMTgkceuTBarOI/utgxk0ltjUeArlYgPjIzgRhmoCB3JKXoCQb6f9jR0SHcoWCEUl8SjWsOdN0kdvwJg/4MzSmaPn06Vq9ejYsvvtgu9Oj6zTff7HPb119/XfTlXHXVVRFaLRNpaDYK4R5mRfHAJHho4v2kwf1jUGMkkM3kktrWLhSkuyaJEc4DImvUz3BA0VwB7HoLKN8IVO6EoaEMZ9LtalhaIf2jAcyaOOgLxgH5k4SwsYucJNfgk9y6g7Ds3SMGkGYkGTzO4JEUZSif96d7lf6ea08fjhnDFP+nRg07cIZ6bYg0deipfH5KaQuWT/co39kXTy0SrR5fH24Qt109qwTh5JCa0DYsWxE62WpoQafJKpysuAgfN4wpwUNl6iaLDXF6DZCcDSTnAW3VQO1eoMjVPmQYxje080wztSjyN9jmQXr8unXrcOaZZ0bN0b9oXHMg66bbotXZcYZKza655hqcfPLJojSNYqnJvZGpbe5DsZ3L2UgkZWfLYhNmoCHjgamkzX3i/fajjb4HQA5ADtWKhhA73mKCnW+XiWNRT2cTsPs9YMdrQNl6Md/GmQ5DJuKHTIe2YCL+fTAFLx1JwxXnzcWPzxzl96knFillrRRNPTov1eMMHvdZPER+WjxumTvSLkIpJMJkscLglJzW3KG4bZSqRmQkKeJBSWkLnOrmTnuS3JwxeSIxjQTPmjALHoq9PlqvuIjDchXBQyV7tD9O1Vb0u1WQGtnv0ZgqaZPDR+3XaQBpWbWS1MaCh2FCgnaWg91hpsebzWYxIDJaxEM0rjma1x0sl19+OWpqarB06VJUVlZi6tSpWLFihT3IgIZiu5f00YyeDRs2iNABZuAij5inxdm6zUMhYk3wHFaHQUrq2jyLGecBkVI0RiXmLmD/SuDb14B9HwMWp/dSfCow9nyR1mvKHoOVa7/CokWLoDUYsLLsSxyw1SErNbBSrwmFikt4uK7dLipz3WbweBI8d503TgwvTTTooNdqYLbahOs2KD2xm8MjBU+m6vA0BunwfLpXcXdoplBuajzmjs3DQyv24IuDdegwWpBIKXBOke03vrgF2Snx+POlwaUZk2tKBgMJnEFpCfaDpDkp8eI+4Sqy4Om9OTwEKUt7kGzeeKBsHVC9u6+WxjAMw4QJKl/zVsLmPhSbGDNmTNQn1DH+qWr2XtJGnGiKLcFT5ubwOJeuudzu4vBEWUmb1aok8ZKTs/tdxdlxTumddKlyyhzquN2tUkE6XLIUyx9ZyXHCNaQd+s/21fgsaTtpaKYQA7NGZOM7U0XxHLRaRRBUNncKgelJ8KSpcdTS4WkI0uFZo5azzVWHo1KvkVzzFwdrcc44R9LlM+sP2UvuqL8oTxUuwZSz0cBRel/OnxG9Vl8MH40JwUMftk5jg8Wm6R5NTdT4jy1lGIZhGCb6kOVYaQZ3h0fZoTzeGGU78z2kTHV4Egxa0U/hLGy8CaGoKGmjgxdVOxUnZ+ebQPNx14CBSZcAky4DCiYp8xj9IJ0v2kkPFCprox166bx47+FJxLal88XYFOfeSipvE4LH7fNuDoPD02W2YMN+ZfAuOTsEvTZd/u+XR4QYkoKHXM/HPj1o33bXieagBM9h2b+T4xoGIsWjN5Hdm8SE4CGois1icU9qG6+cc1IbwzAMwww4yMGT7kR6XPedzlgsaZMOz5TBGfiqrB71HnY+241ml2ADCjrotzSWAzteB7593XW2Ynw6MP4iYPJlwNDZgDbw0mur1WZ3Ich1CZSJhen4eJcjLdKXSEiK674LrpTANXVz1Jo73QWP8svc2mV2PZDvg6/LGtBmtIhStgmFjhh9Z8Ejg70eWF7q8vOnvp+zVZEUCGXS4XETPFI8ehPZvUnMCB4D5aOrCtdO7hjlnI4CkN2ZEDspLQzDMAwz0GnpMgsXw1togezxoX0DOaR8IEPN5OVqM/nJJZlC8Hjq4XE/Ak+PoW31Ti0CfUp7PbDrbUXoUMqaRBcHjF6oODmjFgCGwF0JZxo7TGJAp7O4CISJRa77kd4cHm/IkAN3genew5OWaBAmFZlaUgz5Y/WeKns5m3OZGZXVkdtX0dSJPZUt4rU++LYC9JDvThuMN7cew0416CBYwTPcTfBI8ejcHxYpYkbwyJwCFyWcmKHYnC0ngJq9QLHvoXMMwzAMw0QPstk+JV6POJ1jroyM9qVGcTqSXdHY2e1o9EDkRGOnmlarxSR159zT0XZ5G5VYkSCknX+6LT+IsqawY2wH9n2kODkHPgGsckdfA5Scrjg54y5S9u16SL0qAtMS9C7BV/6YoCa1SYJxh5wFknsMuKOHRxE8Oq1GRFTT7YFGU3+q9u+4OzUJBh1mj8jB6j3VWLW7Cst3VIjbr5g5BBdOLhSCh0raQhE8MqHN3eHhHp5exKD+vrqUtMkBpCR4KLiABQ/DMAzDDBhkaVBeKu1oue5EUukOJbUdrGkTZW2xIHhkelhJdpLT0Xaj1x1+Kn8iF4F6Skg8RlzwWMxA2WeKk1P6PmB0ClygXhxyciZeAqQXhfVlKa45NMGSYB9oSzv3wYglub2nVDx3h0f28dDtgfTxHKppFelxNOD09FE53e4nEUSC57FPD4j9ZDoYcPv8MdDrFCdIBg0E0s9E6W70eBla4Ey2un0tC57eg0bvEF2qte0ieA6uVqKpGYZhGIYZcJHU3kqLKLiABI/cQRvo2I+85ySLuGFvR9vlDn92svIYIXiEeAyt9J/mylhttsDKBklhndiqODkUPkDzEiUZQ9SEtcuU0SJeaGo3iUSzUIdEy88kmMACCTlnJB6CLWcj5DbOoQXUV+MeWmBPaqtrD0jwrFHdnZnDsoXb6Y50faQp8KsFY5Cpvnf6XaHfGyprO3N0rt/XopJJ+hGmxuuR45ZwJ0MLpKCOJLEjeOwOj1MPj0tSGwcXMAzDMMxAQh4pJ6fCE47ggthIanOkZ6XYd+ap8Z2OylNpU7dI5uQ4UT4FNPcoqe0n/9mMreWNWHP7WXah1Y26g4qTQ6e6A47bE7OACd9VStaKZ/pNWKNI6Gue24Tb54/GLef4HxjqcSlqj0mgkdTOTJCCJwQ3TPbwOIcW0M9H9hNRGZvEntTWYYQvb5IE04dqmZpMZ/P0/2BsQaro4Rk/KA0/nDHE8X4K0xTBcyIwweMcWOAuOKWA5pS2XkSWtHVLs+CkNoZhGIYZ4CVt8YCHMCv7LJ4YcXjkfJRhOUmiP4VKnKinhwSO8zBM5x1+WZYV6vBR+mzlPBdK+5qjzoCB2Qi0VgJ7livzco5vcWykTwTGLlKcnBFzAX3gwkP2qlAgwy0hrdjRw5Sl7qAHw0VTBuGjHRX43rTgy+xkSRs5bBarTYhNWc5GMyUpXEAiwxQoYMGX4CGxs628Ucz9OW9SgdfH3ThnBB7/9CAeumSyKnIdQQwUYrDreGB9PFIYF6R3F3zOKW2RnoEWM4JHr6UPVtO9h0cmtbVWKakfSVl9sj6GYRiGYcKL3PkSDo+HoKlYGz7qKGlLEUffaQeUEsHoiLuL4HHa4adgh4CGj5KAaa8D2mqgaa5CUf0X0G4qR/2hw3hAfxA5mmZM+MgCfNwCtNUCXW4/EI0WGH624uSMPR+It4+JDwoSVT0VsdKBcC/JCoSRealYddtZIb0uvR6ZIiR2SITS721zh9kpmc0hROTwUSpp8yatKF78gQ+VA/okaJyHmbrznalF4uSODLcghycQmtRhqNKBckY6ZmQ+tHa5VVz1MrHXw+Ne0hafotSEUo47uTwls/tkfQzDMAzDhJeqZmUnPTfFm+BRjkLHQg8P7f/I9ykHQlKJkRA8bj0VtMNvgBlF+kZojXU4XbsDJRU7gS83CEEjBIsqbpTLtcp4D6edy5PpwhFgIrkEcm+zEd1FTuE0NXzge0BK4LNePEFCYbeaKEbvVc6ViWQPT0+g2G8qIySHhwQmCR5HYIHrLjsFCxCih8fLMp9YexAnmjpFydoNZ40IaU1yZs+RunaxFuc+Ik/I1DhPcd40e0gmI9arwihSxIzg8VrSRuSOUwQP9fGw4GEYhmGYAeXwUElbvYf7B2ck2d2AUHeOo4XyOqWZnJrWhXPRUolLsRKt+nIM/fwtYFunIl7aavBYQyVSEtqAT5RtL6B9V6oUW+HnRUjAJGXDlpSD2g4go2gUXi3tQrUlFfVIxciSYfjR/JOB5BwgORdIyAC02rAOVZUDM6mih4SL154hH9TaS/qC37an0PBRRfB0YYKHSGqJdFAavAge+nn/a90hcfn3F4xz6dEKBnKSBmcm4lhDB3adaMJpI7qnvDnToAoZ6UB5cnnouTwNvO1NYjC0wIPgoaSP/R9zUhvDMAzDDCBqnEILPAme/PR4UUJEw0lpxzHSR/Qj3b+jgwWXpe2B5n/PA/s+xhKbRdkTLHd9bIp6btNoYY7PwsH2RLTp0jF9/ChFqCSRYMl2uuwqYMwmE75YvhzJI0/B777ZZn/emdYs/KhkVq+9x51ufSYURhGKaHEObYg0NPuotMLxu+spoc2lpI3u9zB66L4Pd4uD/KePzMHCCd57dwJhYmG6IniON/sVPDI1zlNJm/xMheCJcDR1DJa0eRI8HFzAMAzDMAOJDqMFLV1m+xyevR4eQzHJVO5GR9OPN3QMXMFTfwi5m/6JL+LfQn5LI+SHcTR5IlY3FWL40KE4c+pYIVpsSdlY9MweVJhT8P4dF0Cn0+HcP64RAQf7vn9eUC7Y2n214nx0fgr2VbX2eq8URSc7Q2VtkwYHH6Ute5hCSWnrKY5oaqUcs7nTs+CxhxZ4KA2jpDoaIqrXanD3heN77FxOLErDil2VAfXx+Hd41KS2NqNdWEeCmBE8XgePOkdT0/BR8nsHsKXNMAzDMNEKlfd8c7QRs0fmuCRJeULuMFKylafZIxJq1heCJ8Sd436LqVMZ1rn1BeDwepxEt2mAdn0Gkk65CjhpMd7bqcOfPt6LSzMG48xTpojN2rrMKDUrO7bZqQnQqyVnlOYWjAtGu1Myne3qU4fi9+/uQmVTpz19rDeQgQW0o2+22kIKLqD1yZ32vhDA9uGjajmmvaTNKZLauYenSQ01kJCrs+y9XeLyNaeVYFR+aOEPzlBSmydB6cvhketzR36m9REWPOErnIzWOTxEzmjlr0BHvdKAxzAMwzBMv+PB5aVY/NwmfLyr0u9j5Q5jflqCzyPcjlk8AyS4oHIHsPwO4C9jgLeuE2KH9nG2xZ+MG4y/wKrz1gIL7xcptbJkSzoahOytIKFITeYUSy13UmUIREDL6CCHpVNsf/G0IiFySDTJYbDhxuoUWDBrRHbIP1NyTGRicpYXl6I3sc/iUUvaHKEFbg6P+jMhceac8PzeNydE+SL1ad06L7Q5RO5MKFQEDz0vzQXyhXScPIUWOLtmzr9zkSD2BI/Jg8MTlwRkDVMuc1kbwzAMw/RLDtUosco0INEfcofR38R7mdQW1YKHEtI2Pwc8NQd48nRg01NAZyOQXgzMuQv4xQ781HoXVlhnoCQv02N5kaRWTWyTQyJdy6wCFyu7GxSROWt4NlITDChI691EvPL6dlHCSPNmzlIHZIbyWvVtDoeCUtMijfysq2RJm7ceHvU6iUij067tJ7urxPkVM4d2c4VChXrg6OdHwqq0otmn6JQCzVcPj/PnHClip6RNY/Ne0iaT2uoPATV7gOGh5aczDMMwDNN7yPjkQMSJY+io74n3UTuLh/Y+yzcCW/8L7HobMKvr1xqUOTYnLQaGzwG0OnFUvrrlW3F3iRpJ7TIIUk0lc3Z4nPtXaIeXRGZ1EA7PrgZFLJwzLs/upJEAoZ/d9KEO0RUuZH/J2EFpKM5ypO+F3L/TR/1clNIWiMOTFKcTw0iNFivazI5ytg0HlL6pc8b2LOLbHerjqWzuFGVtp5R4nllJ/UZW1W3y2sOjCmnxOfuamBpmYkfw+IqlJvLGAXs/VPp4GIZhGIbpd8idUQoYCGroaACCh8qvooLWauCbV4Ct/wHqDrj2I5PImXy5kprmxGF14CjtxDvvOMvBms6JWVJUOu/wu/eV+IN20stUE+7sMXkRcdJk/87EwjR7mWIoP1NHQlvkI6mdHR4q/aOodEcstesuO5VpkgtFPxNplnx9uF6I25yUePvA0HAxoTAdn5RWd0vC8zSDJ5nEmCytciOrj0raYkbw+OzhkYKH4GhqhmEYhul3mC1We0N0IG6MvaRN7YmI6h4eqwXY96kSQLBvBWBVD+kbkpWBnSR0Bp/iNXSpTBU8cuCou8PTbrSIVLvEOJ1TQplTSZv6GQbaf7N+fy2s0GBkbrLdbSns5c+ZIpNlg738mdI8nU6TJagZNH2Z0OYs0Mm5IbHjbQ6P7JMhwdNuVn7uq0tpWBIwZ0wutGEOhpgUQHCBv4Q2IkcVkg0sePpgDo9LUlspJ7UxDMMwTD/DeTJ7RWOn6BfwtVMXaEmb3DmmnXk6KEpR1f2GxiMYW/Em9I/eCbSccNxO4mba1YrYifefwiUFj3M5G0HpdXQknqpfyNkZHJeEOlnS5uLwuEYlBxpHffYYpZemt500ckJkSRvtmJPzkWjQiSGklAzn/r4DcXj6KqKcxBm5cCR0SMw0d5o9lrQ5J6HJkrZP91b3Sjmbc1Lb/uoWuzh2p8lPQpuzw1PvFrbQ28SM4DFo/JS05YwCNDqgqwloqQDSCiO6PoZhGIZhvONcdkVHv6m53peYCTS0wH3neGh2BBsLPGHuAvZ8IErWDIfWYoy8PTELmPIDRejkq/MDA8Sbw0NlUSRsKpo6hdAZnJnkKOlK8VDSpn6m/mKd1+1XBM+cMTkRcdKoN4jcP5oVNCo/RbwvKqE7WNMmXi8YwePJ4Yo09DsrBE9zl9dYauckNBI89DOmE30Gp4/yPRw01IGoVAJZ22rEnspmTBuS6dXh8ZbQ5iykKWyhw0vRVW8QM4LHb0mbPh7IHgHU7lNcHhY8DMMwDNNvkM6D5ERjp2/BIx0ePyVtzjvH1BsUCcFDZVb/XLPfJakqv/MQTql/H9MaPkaSxdEnUZY4EcXn/gL6CRcp+yohIAXPcA87/iRsSPBIoUNlYESWUw8L7ewG2sOz/WiD6OVI1NlwUnFGRMIhZF/J6PxUu0NHryd+ph4EFrmDz39xGCeXZGLyYMcaXXt4+m4ILf3O7q9uxdGGdvuB+nQProl0UtrNDleNAgUoFS/caDQa0cdDQ013nvAmePw7PORgUY9Pm9GC1ggGtcWg4PHi8Mg+Hil4Rp4TsbUxDMMwDOMb9yZnOnI/1WmH2hnaSZQ7X/5K2vztHPcGr28+isc+PYhkdOAC3Zf4ge5TTNM6AghO2LLwumUOXrechQ5bDr4cvxDQh74Te6ROETyexJwUNlLo+HR4WjpF+ZivuUZfHqoX52MybC6xzjK0gJwYGm6a7GMYbLDIvpKJ6rwYV0epewndmj3VuPeD3RhbkIoVvzizX/XwEPnq572/qlWcU+VmSlz3z0v2yrSZNFirDnmd2wvlbJLxhWlC8OzzEgvvbwaPhNyztvp2Fjy9WdLmcQ6PczQ13gVqeBYPwzAMw/QnnKOT/ZVG1aiPpfIemgdiNvseluhr57g3WL+7HLfrX8P1hhVIsCmvadHoUJZ1FnYXfAflmaei3WjDsXWHoDfahMgIlXaj2S7+Bmcp79OZHPtcFGVn1WMPj+rwdJqsYtaNr/kuclZSUZLrmsl1SE3Qo6XTLH52o/L99x4Fiuzfoehkia+QhG+ONYrzfVUt4vOhAasS6br1VQ8Pkat+3tQvIwMLPPWryVk39VQFWdPQ64KnUP1MvQ2gdZS0+Rbn9NmKuUmmyPXLBzVR6cEHH8Qpp5yC1NRU5OXl4eKLL8bevXv9bvf6669j7NixSEhIwKRJk7B8+XL0lcNDdb9eyZPBBZzUxjAMwzD9tYeH8OXGyHkx5Ez4ciMkvZ0g5kzXzvextHwJbtG/o4idnNHA/Pugu30vRt7yNi669Ee4ed5Y/GLeaPF4s02D1q7Qmx3ke0qN13sUKvZZPG3URG5zxFI79bBQGRKJlUD6eMpqFVci14Ox5oiL7ghvYIHq8ExwimL2VUInH08zY0orWjz+nlG0c18hHbWD1cpn6U1gSieltFEjemJKspMwPDelF9cV77O00VHS5lssyjh0GbbQ7wTPZ599hp/97Gf48ssvsWrVKphMJixYsABtbYqa98QXX3yBH/7wh7j22muxbds2IZLotHPnTkQSg1YOHvXxRyNPbQKk4aORjI5gGIZhGMYn1CztvLPkaxZPoDN4Ijp8tOEw8PLliH/jKgzW1KJSkwvbZf8FfrYJmP1zIMWRaEZQChYNl3RPqAsWmYom36M7UtiQs0PuDe04i9vdHI5Ak9oO17WL89xEW0ScNPpZ0++GTqvB+EFp3cWVh98T6kGR7FLdIYLeemNH3zs88rM+0dTpNaHNuVeGRDExd2x+RNZV40XwBJLS5vzZtpj6qeBZsWIFfvSjH2HChAmYMmUKnn/+eZSXl2PLli1et/n73/+Oc889F3fccQfGjRuH++67DyeddBIeffRR9EkPj6+StqzhyoRiYyvQdDRia2MYhmEYxjf1qvMg43F9iRMpePwltPWm82DH1Al89jDw2EwxQ8es0eNx80V4etIr0Iy/yOcYjCxZsuQW2BCKwyN7aNyRwoacHVnORk3l7rNrAklqox4O6ZB4cnh6w0mTbs3I3BSXNTv/TJ1LAsn9c95hd54rIzMk6Efirw+lN3H/vfUmeDLdRFlvlrMReWkJLkNRQ0lpcxbZrREsaetRD09Tk/JLkpWV5fUxGzduxG233eZy28KFC/HOO+943aarq0ucJM3NihInR4lOwULb6J1iqX09hz57JDQ1pTCf2AFb8iD0JXKdobznviIa10zwuiNLNK47GtccjnVH2/tlBi5yZ3xyUbpo0PblEtQ0B5bQ5iky2V9TflAc+ARYfgdQf0hctQ07E1cd+z6+7MjBvycM9bs5zSw51uhIUAsFKS6KMr05PI4eHikq5awUZ+Rn6cvhkWlw+anxiNeZIyJ4dtjL2RzujlhDerwQLhRWRe9N7mTLxzu2d7g9somedtjJMeorpLCQpCV63l3PcBJCJFJnDPO+Px4OctXPkNpDKHzCXXA1BujwSJEdFaEFVqsVv/jFLzB79mxMnDjR6+MqKyuRn+9qsdF1ut1Xr9CyZcu63b5y5UokJSkTe4PFoDo87V1Gnz1E003pGAxg74Z3cWB/BIsLfUDlg9FGNK6Z4HVHlmhcdzSuuSfrbm9XylMYpq+RO/3S4aHr3gYgOhwe/wltzjvH1JRPfQg9LmdqOgasuAsofU+5nlIALLwfpVnz8eU/N4i5P7OGZ/t9miz1SLl7Ql0wSNfKW0mbvYen1WgvG8x2iqTuVtLmw+E5rKbBleTQvlr3dgfpMoXTSZOR1M4JbQTFU9MOOv0ukDiWgkc+/tThWSJRbn9Vi4gJp9+iFrOmzyOpg3F4nHtlThuRLYbI9iZxeq0IJKD/I/S5uguewB0eVfCYo0DwUC8P9eFs2LAhvCsCcNddd7m4QuTwFBcXi36htDRXBR/oEco3Plxlr3NctGiR18dqN5QCn32JcdnAaB+PiwS0btpJmT9/PgyG8Geq9wbRuGaC1x1ZonHd0bjmcKxbOuwM09fI2GQanpkSr0drl1mUtY3w0KQtU6QCLWlz3TnuCF3wmI3Al48rJWymNmWg+cwbgDl3Aglp+PRTJXp69sjsbiVj/tyXHjs83np4VHHjXNLmaYffEU3tXfCUqQlt1Dzv00kLY6+U7MGRQtgZEnm0XhJYkwanuyS6zRuXj31VreKzpbS2cfnJ9pK2vuzfISiyW86qkSltnnB2Us4e49oD1lvkpSYIwUP/x8YUOJL2qEe+XV2vX8Gj/s5FMqUtJMFz880344MPPsC6desweDD5Id4pKChAVVWVy210nW73Rnx8vDi5Q1/Woe5oyJI2SuTQaHUu2fCuC1bcKm3tHmj7yU5NT953XxGNayZ43ZElGtcdjWvuybqj8b0yAw8qR2/uNNvTs2jHeW9Vi9iZ9yR47A5PgCVtzjvHxxo6PO48+6VsPfDh7UCtml5bfCpw/l/s+xVy/gtxdoC9FuFweE74DS1QXoPcrWMN7V5n0ARS0nZILWkroXk/Ho6VyDVUNHbCYrX1uGysqcMkhqYS4wZ1j7mm35PtRxtdSuh2qSVtk4rSMaEwDev31wrXhwSPbKLvy4Q257I2WSLozeEx6LRillB5TTPOHpMToXXFi/977sJXlrPRj1Qm+nlDCkqnubu9TlDeF9W1kth5++23sWbNGgwbNszvNrNmzcLq1atdbqOjjXR7JJElbQENHyVq9gHW0GMgGYZhGIYJD7JUhnaQaedPlkZ56wUJtqTNvY8nKFqqgDevB164QBE7STnAdx4HlnzkInbISdharsxKOXtMYILH4fCEtmdotdpQobop3gQPJcHFq6VQ5Hg4DyN1Ribe+XJ4ZEnbMC8ODzlu9DM0W21ek76C4bAqCOh5ac6PO+6/JzTLSSaf0RBNKWyl6yOb6Pva4XFPGPQ19+ilH5+MO6daIibS8pyG0HoSPOleZgY5Qy7tU1dNw/VjLf1T8FAZ24svvoiXX35ZzOKhPhw6dXQ4/jgsXrxYlKRJbr31VpHu9pe//AV79uzBPffcg82bNwvhFEn0gQqezBJAnwCYO5QISYZhGIZh+hRZakWlMrQzJXfeZeSyM+QcyCGlgZa0Ef5EVPcXMgNfPgk8ejKw4zXK9gJOvha4ZTMw7UpA67qL9dm+ajHxYtygNK/iI9wOD5UBUsw07X9SkIAnKKBB7izLQZcy+tuZfJnQ5aWHhw6Ky5K2oV4ED1XXFKSFr49HOiAlOckBldDJOGra4SaBJPt+ZFKbbKL35HBFGuffXW8Ojyx3S4/gcvOk0+f2exBo/44s2aMSvCG9NzKoZ4LniSeeEMlsc+bMwaBBg+ynV1991f4YiqmuqKiwXz/ttNOEQHrqqadElPUbb7whEtp8BR30BvSfXa8qTp+zeLQ6ZQiYnMfDMAzDMEyfYh+GqR55L/QxY4XEDpWv01e+8/DMsM7iOboJeHoOsOLXQFczUHgScP0a4IJHgMRMj5us2VMjzueODbzXoqc9PFJUkMjwWsrv5GiU17d7dTjkDjjN6qGwCHdqWrtEzwl97sVZSeETlj6QJXTDvQged2EshY10diaqyW57KlpgsljtTfR9HVrgLDD9CZ5Ik+dlFg9FkgeS0NZXBNXD4ylz2521a9d2u+3SSy8Vp76GLFuz0SJqgX1CZW2V3wLVpcDY8yO1PIZhGIZhPCB3+KUA8FV+JkuuyLUIpkfEMbfFx1DMtjrgk6XAtheV6wkZwLy7gZOuUQ6YesFsseKzvdVBz0qRDk9PBY8/R0l+rnI3z5NQpKAISpfrMFlEOdNQ6tNxQro7gzOT7CVynlDW0hAWwSNL2six8f5aDmFsDzgoVITOkKwk0W/S0mnGgeo2exN9MEK5rx2eSJPnpaSNggyIvpxf5Iveza/rZ8i4Pp8lbUTuWOWcBA/DMAzDMH2KjEuWzoMvN0buiAUTWODynJ52xK1WYPNzwD9PcoidaVcBt2wBTv6xT7FDbDnSIEIXKNJ3arFnB8inw9NuDOigc7AzeCTujo4nh4NK3xzBBV1Bl5f1xiyeQEvaqLSPoqftEdaqw0PvSZa17apo7jcpbe6/v95S2vqCPC+/A7KkzTkquz8Rm4LH5M/hGa+cc0kbwzAMw/Q5ciCm7DWRZVGU9kWN+c7I3oJgAgucd46pVMel9P3ENuCZc4APfgl0NgL5E4EfrwS+8xiQHFgy1hrV3TlrdG5QrlOWWh5EfTgypS6cCW0S94Z3bz0svmbxlNX5Li8LykkLANEz5KekjcqryJUi9la22Ev2KJ1NIsvadp9odkpp6/udduff3/7l8MTbfwecRXiT3eHpP2uNWcEjLVajxU8qRJ7q8NTuU5oSGYZhGIbp89ACeeSd+htIN9DE91pVDEmq7IInOIfHeee4kpK8OhqUmOmnzgZObAXiUoFz/wj85DNgyMygnnut7N8Z5zqI3R/xBh3idcpOpQxi6I2SNndHw5vDIXfCK9U5R8HM4Ak2Da+l04QFf/0Mt7yyzavrR7OYaGDsEC+vSQ6OFMerdisjUoqzEl1cCOn2bD/WhA6LTGnrXyVtaX5iniNJnvo7QKWN9Pl3d3hY8PQbwePX4UkfAhiSAYsRqD8UmcUxDMMwDOMRmVImnQeaPyKbuqWLIdl8pF6cj8wLLgLKsXNsg3Hzi8A/Twa+fkZcx6RLlfS1U28EdMHtfJJbtE9NPzt1WBaCJUV9uVD6eBxDR327Xc4lbKnxejGI1RPyM92ifsbOSLdlmIe5SJ6DBHwLHppZRDHZ739zQogfb69HAsrbep1fb+XuSnEuS9gkE2RSm5rgRkI6ox84KtQjNSY/VbiCvgInIk1inE78jjgfXHDu4eGStn6A/A/ht4eHoiRzxyiXa7iPh2EYJhp47LHHUFJSgoSEBMycORObNm3y+fjGxkYxboHSRmnY9ejRo7F8+fKIrZcJHOluOO+Ye3IK2rrM+OqQsjM+J8BZN87MSKrEa3H3YtTG/wPaa4GcMcA17wOXPAOkeh+Y7ovyunYRBkBN/86zVQIl1eDaxxQMJ4IMLSCyfJRzyYGp6/fVilQz5yjwI2q5mL+SNum40NBQZ4fAHTmklSitUASjM2W1rT4DCySD1f4lOWPIfagsbU+ziGR1low+7w9tGB/degaeX3IK+hu5HobQypQ2Di3oV6EFAQw6kgNIObiAYRim30PjEW677Tbcfffd2Lp1qxiDsHDhQlRXO3aanDEajZg/fz4OHz4sxiXs3bsXTz/9NIqKiiK+diaYlLZ4n83vGw7UijI3St8aket7R9iFzmZgxW/wh6qbMEO7FyZtAjBvGXDDBmDYmWGJTqYda3KRgiXFYAvJ4Wk3mu1H3f0KHqcSLl+RzJOL0kV/C0VTf33Y4fLQz4AScON0Wr+vRfNvKBmNqPDi8ohUu31KGaBznLQzZbUBCqx01/U49+8Q1FPlfFt/iKSWkPAK5XemL6KpG7iHpx+WtPlzeAgWPAzDMFHDI488guuvvx5LlizB+PHj8eSTTyIpKQnPPfecx8fT7fX19WIu3OzZs4UzdNZZZwmhxPT/Hh5C7lgfc5rF8+keR/RzQDuKdFh/xxvAo6cAXz4GHSxYbpmBP418ETj9F4A+rtejk/2Rou4/BtvDI0v9qPwoLcH3Tqjz5+qrf4V2wKVztqbUcTDhsBpYQL00gYQyOIILPAuebUcb0ajuQBM71ThpTw5PoKlwEneHx7msjchK7p877P2JfLWc1Dm8wjGHp/8IRmf6TxdUf4qlJnJVwcNJbQzDMP0acmu2bNmCu+66y36bVqvFvHnzsHHjRo/bvPfee5g1a5YoaXv33XeRm5uLK664Ar/+9a+h03nuB+jq6hInSXOzUvNvMpnEKVjkNqFs21f0xZrpO5scBSI9Xmt/7QK11ut4Q7u4jRKjZBnUmaOyXNbocd11+6Fb8WtoD68TV22Zw7Bu5B24aX0GZrelhu09HlT7d4ZkJgT9nPR42cNT09IZ1PbldcrrDkr3/7pp8Q6RkpWk9/n4M0dm4Y0tx7BmTxV+vXCUuO1AlfJ/oSQr0eX/g7fnKUiLx57KFhyta/P4mE92Kf025CZRKd/OY03dHneopjWgzzVf1gSqr+v8OyQZV+AQTeRQ8P9J3+SoorCyyfF/TwrUlDhNQGvp6bqD3S62BI8uBIen7gBgNoblKA/DMAwTfmpra2GxWJCf75qARdf37PF80OrQoUNYs2YNrrzyStG3c+DAAdx0003iS5TK4jzx4IMPYtmyZd1uX7lypXCTQmXVqlWINiK55kahMfXQamzYsGaVSOUijjfQBR1Ky6vEz/BoK/UU6BGntaFhzyYs3+d53RqbBSOqP8LYirehtZlg0Riwr+BCHMhbhL11irux/3ht2Pq5tu4nAa1B07H9WO5pUX5IMShveOf+w1i+PPAgpY1VyuejNzYH9F7itDoYrRrUVx7F8uVHvD6uw0yN/Tocqm3HC28uR24i8GkZ7V9pYW1Sfhb+fk9MTcrj12/ZibSab7vd/943ymc2O7sD77bqsL+6Be+8vxxx6rEISiIvq1Eec3jHJrTu9/6+ajsdu7s5ug6Pn0V9m+MxrXWVUdnLF8n/k7UnlN+t7XvLsNx6EJSYbrYqn99X69bYf069ue72dqWkMVD0MRlLHYjgSSsE4tOArmZF9OSrs3kYhmGYqMdqtSIvLw9PPfWUcHSmT5+O48eP409/+pNXwUMOEvUJOTs8xcXFWLBgAdLSXPsCAoHEFX3ZUy+RwRAdZTSBrFmZj9KOoQGWN/ljF6Vnbf0SOSkJOP/8s+y3D69swdN7NqLNFodFi87Go58eJD8FZ47Ow0UXTPO47gVTixG/4pfQVmwXt1uHz4X13IcxMrMEIwGMr2/Ho7s3oNmiw3nnLQioLI4GMOq1Gq9Rzvfv/IwOteLic07D5MHdy6l8Qev++uVPxOWE9BwsWnRywNvu/eQAKXtMHT0Eixb534f5U+k6HGvsxIzJ47DotKE+H/tO7df4sqwBtsIJWDRrKN76z1agshZzZ0zEopMH+/09ObquDJ+v2o+knCIsWjTJ5T7qB6rYuF6kpf3uinn44p+fo6bViKFTT8O04gx7KZz5y/Uw6DS44jvn+kwxo4Pcf9j+iahenDt1FBbNHeGxZ+hvu9eIx04dOwKLzlGcq2igL/6OmL+pwLtHdsCQmo1Fi07B0YZ24OsNYj/74gsXRWTd0mEPlNgSPIYgQgvoj1zuWODYJqB6NwsehmGYfkpOTo4QLVVVypwNCV0vKPCcrEXJbPQl61y+Nm7cOFRWVooSubi47juvlORGJ3foeXqyo9HT7fsCX2t+Zv0h/OHDUjx8yWRcdkpxj1+rqUs5SEmCwvk1h+Sk2pulzTYt1u6vE9fnjS/ovjaLCaMr30HCC+9DYzWRegAWPgjt1CugdRI1g7NTxNd/p8mKVpP/fo6j9e1Y9PfPkZZowLr/O7ubwKMUMjmRfmRBekg/Z1mRVd9uCmr7SvV1B2clB7RddmqCEDz56Yl+H0+fMQmedfvrcP2ZI3FYTWgbkZfmsq2335PibKWErLSyFTqd3iUVbd3BE+L8pCGZyE1PEj03n+6twd6qNswYnivuO9rYKM4pnCIxwXfyHb08NdlThPLk4kyP66Gbxhak4ptjTchNS4i6/4+R/jsyKFNxtEmI0mu2Gm32hLZg1xDquoPdJjZDC/zN4XEva+M+HoZhmH4LiRNyaFavXu3i4NB16tPxBAUVUBkbPU6yb98+IYQ8iR0mcN7cetxro3koyGb9HKeENjmMkaKeiR3Hm/DtsUaX6GQ7Fd9A/9x8jKt4SxE7YxYBN30FTLtSObjpNr4iV32d405hCN64/8NS0V9EjoPsKfEUWEDJX+khznaRKW1yFlHwM3h8p6ZJrj9jGM4ekyvmvvhDfsYUAU7N6iT8iOEBJuOdNiJHREHvrWrB29uU35duwRPj8lxCBnYebw45COJnZ4/Ewgn5OH1UjtfH/PSMYRiXYcXcMf7ff6yTpw4flWLeMYOn/wpFbSz28FBkZUBwUhvDMExUQKVmFCv9wgsvoLS0FDfeeCPa2tpEahuxePFil1ADup9S2m699VYhdD788EM88MADIsSACR3ayS6taLbPWQkHMo7ZvWTMMSgUePmrI6JkieKFZYIUzF3A6vuAp86GpnonunQpMF/8L+AHLwNpg3o8GHPD/lqsUJvrvSeJ9SyhzX3wqJWaV4JMafMXEy25YHIh/r1kRkApWxQFTSWLtD/18qZy0VNDAkbGFfuD5hHdMlcpG3vwoz32waIdRgs+P1BrT9pzHQza5DHqOxAWzyrBv64+GQkG780l88fn4YZxVsfvD+OVPHUOT0unWfzM+vsMntgdPBqow0MlbQQLHoZhmH7N5Zdfjj//+c9YunQppk6diu3bt2PFihX2IIPy8nJUVFTYH0+9Nx9//DG+/vprTJ48GT//+c+F+Lnzzjv78F1EP5/udUQVh0vwyIGbzsMxJdK9WL5DER7nSHfn2BbgX2cC6/8M2Cywjr0In457ELYJl3Rzdbw9p/N8H3do6OY97+8SlxPUcnlnB8Jd8PiLTg4klpqGezarwsAfJIwqmgIbOhoKJDalIPnPF0rAQUl2cHOGfnx6iRAsta1d+OeaA+K2jYdqRR9NYXoCxuQrJYsTi5T+uH1VLfaWBIfDkxLmd8YEAkWdy997Gj4qE9oy+3Gkd4wJniB6eIg8tW+noQww+be2GYZhmL7j5ptvxpEjR0R09FdffYWZM2fa71u7di2ef/55l8dTuduXX36Jzs5OHDx4EL/5zW+8RlIzgSHLkYjmsDk8XV4HQsqdeVm5MXdkGrDy98Cz85Ry9ORc4NIXYLnkOXQZAgsMkK6RL8HzwheHcaC6VbhOdywc63U4Zk9n8BC06yIHdUrx5w8SESaLTTT+5wfougSLFDyVzYqTNCyYQa/qQeilFyr7Wc9tKBOf5xqncjYpnkiAiqhoiw37KlvdhGTo6YhM6NDPxrmsrUF1eNIT2eGJvjk8REoekJgJ2KxAbfBRkgzDMAwTK3SaqBxJCQ4Ip8Mjh45mu/XwuLsXc5MOYcqHFwBf/EP53p50mdKrM+HioF5PPucJ1SFxh6bL//0TJQf5/xaOweyR2fY0OfeSM1l6RSVgPSFLLRWS5X3+kOV4BWkJPhPMesKMYVmijE0Syns8e0yecOXMVhuWvb8Ln+6pcRFTcufa3sdzokm4a0fV/qrh7PD0GXmqkKbho3aHh3t4+pfgCSiWmqCjC9LlqebgAoZhGIbxxsZDdegwWexJZU00sCUMyGZ9T7HPdPQ/EZ1Yqv8PnrH+HhoaI5FSAPzgFeCSp4FkRYwEg6OHR3Eu3Hl4xR4RVDCpKB2XnlyMkbkpooKEEtmOqM374Sxpcy7nkwEOgfbvFGWGv5zN2aE5faQjBIBK2kLh9xeMFz3W6/fXCqFGn+Ws4a7hAvY+nuNNIiCByvsSDTrkq70kTOTJV3udqKRNOjzcwxOtJW3OfTw13MfDMAzDMP7K2eROcKD9JpL9VS344FslktiZOrWkLcdDD8+Yju1YEXcnfqxfAS1swNSrgJ99BYwNbBZIsD0824824vUtx8TlZd+ZIMQdOSjjBqV1K2traDPaXa5QxYAkSz1yHmhSm1x7b/TvOHOOmqQWSkmbhMTg9WcOs1+fPTIHiW6TK2Ufz84TzS4iMpieISa8UPCEo6SNU9r6qeAJ0OEhOKmNYRiGYXxCw0Zl/8V3pxXZqymozC0QSBz98OkvcfPL20T6mTP1aklbVrLT0fyuFuCDX2LcyiswVFuNE7ZstF32KnDxY0CiMpyyp4KHStfcD5A+sVZprr/kpMFiTkz3HfLuSWLUgO++Ax+6wxNcSVtvCx4qSSNDj4RfT8r2bpozUpTfuZezSSaqDg8lAO6vbg1LmSATnqQ2KmlrigKHJ6YGjwZd0kaw4GEYhmEYn9BO6LEGpRxp/vh8sRNM7SzkcPiKApb8bdV+e0P+qt2V9nkpJJjajBbXlLYDnwDv/wJoOiqulpVchvLpd+Ks8SPC8l7oKDWVS1F5XkVjp70cjcQPlV0RS2aXeNwh3+WU1BaucjbXHp6ufiV48tIS8PiV04XgDSTO2hvJ8Xo896NT8ElpFS47ufuwWhowSslgVEq4arcyYJgDC/qWvFTnkrb+7/DElOAJyeHJVQVP4xHA2AbE8REFhmEYhnFGujuzRmSLnde0RINoZCbB42+uCZWyvbDxsOO59lbjHptNlCvJEi6DToNUWyvw7u+AbS8qD8wYClz0TwwbfhYcBVE9R873OVjTJkrDpGChIZvtRovoG6F5P87IpnoagEo7//Qc4Uhok2SpYq82yJK2IjVxrjc5d2JBWJ5nfGGaOHlCq9VgQlEavjxUjy1HGsRtHEndP0ILapxS2noienubGC1pC6KHhxoeKdaSoIhLhmEYhmFcsMcJq+VIaQmGgKKpSRzQPBtqQj9zdK6oxDha3yEiip2b9C9K3AHN47NUsaMBZt4A3PgFMPysXnk/noaPyvdIZVzuvSOj8lOEKCOBR05XuIaOdnN4WvtXD08kkS6aJByfK9Pzkjb6XaMBpASntPW3WOpAB492K2tjwcMwDMMwzjS1m+xH3UkMEOmJhoCiqT/eVSmirOn7+Q/fmYhTh2e7iIum+io8YngcfzE/ALRUAFkjgCUfAec9BMT33hF+R3BBZ7cepbM99JhQYtmYAmVQ5i61j0f28IRjx9zewxNASVu70WwvMRpQgkd10SQsePpHSVuzKnac/9/3R2JK8NAfJOcBZUGXtVXv7oVVMQzDMEz08tn+GuHQjM5PQXFWUsCCp8NowX0fKP2xPz1zOIZkJ2HuGKWiQoiL3e/hlA/Pw/d0G2Cl3ZXTbgFu/BwYOqvX35N9Fo/qlFB5W3l9u4hPdo5i9uRA7DzeLARSWEvagpjDI0Ua9bxIp20gIIMh5O9Xf3YTYoHMJINwNSVpCfpem/kUDvrvynqzpC1Uh4dL2hiGYRjGYxy1s/MhBY+vkrZ/rTsoSsYoxYxSuoi5Y/ORjSYsPnY38NrVSOiqwz5rEf5e8hiw4A+AITKOhfvw0TV7lEb5mcOzRI+SJyY4Dcesau6yzySSIjAcDg8JHvfhpl77d3pxBk9fQD07FCahXOZI6r5Go9Eg12kYcKaHOVn9iZgSPHRkJugeHoJL2hiGYZgYgxJN73lvlz0VyxPk7Kzdq/bvqOVsRFqi3ufwURI6T6w9KC7/5vxxSmyzzYYhJ5ZjTeL/4XzdV7BqdPh80DW4wPgAWnOmIpJQaIFcp6ceJU9MLHTM4jlUq/QgFWcmwhCGo97SzSCt0+inTHAg9u8QJB5lqAGXs/UPcp0CSTL6cTlb7AkeQwix1M7DR5uPAZ2OjH2GYRiGGaiQ0Hn+i8P4+SvbPA7hJF79+qjoF6Ed8ulDHXNpKKXNV0nb6tIqkZg6bUgGzp80CGipBP53JfDmtUi3taDUOgR/Hfok3s66FkYYHJHUEWJwhuLK0Pum97D5cINfwUPDR2mnnOK1KU0snDvmJJqkayaDHLwhf1aD0ns/oS3SzB6h9HjR7w3T9+SrSW39PaEt5gRPSLHUBA0xSy1ULtfs7YWVMQzDMEz/giKWCSrNemB5qcewgj99rFQ+3DJ3lEv9vr8eHoqyJSYMSoXmm1eAx2YAez8EtAYcnfILXGT8A146mml/XHaEy2Xy0+NBFVOdJive234cZqsNI3KTMTTbu4CheUMjc5UghQ++ORH26GT5Gciobm8cV3t4BlpJG/GzuSPx0nUzccWMIX29FAaOpDaiv/dUxaTgoT9cZMMHRZ7q8nBwAcMwDBMDyLQx4oNvK7DxYJ3L/Y+s2ivcHQoruHrWUJf77D08nZ4FD+20D0Idri3/NfDOjUr1xKCpwE8/Q8FFdyMhIUH0q3xVprxmdrJjxypSIUeyP+G/Xx7x6+64J4k5EtrCNxzTntTmJ5r6eGO7S9LcQIJ+LrNH5vTr5vhYTGoj2OHphz08IZW15Y1XzrmPh2EYhhngUMqYdHhkqdqy93fBrKac7qlssQuBey6c0K1PRaaDeXN4NA1l+CD+NxjW8AWgiwPOuRu4bjWQrzwXzeQhyGFxHrwZSWQPzL6qVq9x1L6SxMLt8GSpDk+9n2hqmdI20Hp4mP47fJTIZMHT/xyekIILZB9PTXdbn2EYhmEGEtSs39huErGzj195knBsSOS88vUxyhbAvR/uEQ30iyYV4DQPMc0+U9o6GnDT8buQrWlBc/oY4IYNwBm3ATpH+plzAAKRE2GHx90hoYjnU0qygp8Vkxu+5vps1XGiHiFvUIJbhZosx4KHiWhJWzKXtPUbyAKlhsKQ+njsSW0seBiGYZiBDc2SIUbnpyI/LQG/WjBaXP/b6gPYUKXB14cbkGDQ4jeL1O9GN7z28FhMwGuLUWQ5hhO2LOyf/wKQO6bb9nPG5IoeGknfODyOcp0zRucElLZGwQVy3XSQdZBTilW4enh8zeKpbe2CyWIT+zrODeUM09slbf156GjMCR6XaOpgZ/HIP8itVUC7kr7CMAzDMAO5f0cO07xi5lCxM09T1d8oU2ah3HjWSAzO9Nyj4tHhIWvow9uAsnVoQwKuNd6BtNzBXt2MqcUZduGQTLHVEcbZIaH5QIGQEq+3J7OVZCdDqx5kDW9ogfeSNhmjXZCWwH0uTK+TN5BL2tatW4cLL7wQhYWFYujQO++843ebl156CVOmTEFSUhIGDRqEH//4x6irc21+jBTxMpraEmRJW3wqkK6mgrDLwzAMwwxgaJaMc08KOQbLLppgv39wRgJ+etZwr9vLWOo2owUmte8HX/wT2Pof2DRa3GK8GaW2ofYyLU/Isjba0e+LIZNS8NBLk+MUKJPUsrZwz4rJUj8rX6EFjv6dgRdJzfQ/slPiITX9gBM8bW1tQrw89thjAT3+888/x+LFi3Httddi165deP3117Fp0yZcf/316Ms+HtkIGVJSG/fxMAzDMAM6sEApaZvg1JMyY1gWLpteBC1sWHrBOBHD7I20BEc/jnB5Sj8AVi0V11vPWoY11pPEjpKvYYUXTS0UvTOnDldmr0SaacUZwrFZOL4AOT6EmTuLaK5QgKluwZATQCz1QB06yvRPdFqNCDXJSDKgJIyJhL2B4y9SgJx33nniFCgbN25ESUkJfv7zn4vrw4YNw09/+lM89NBD6KtIw5B6eGQfz/6VnNTGMAzDDFiqW7pELwgJknEFrqlj9100HlM1R3C2H8eDyqlILLR2mdFZvhV4mw5y2oCTr8XRUdcAKzaI1DFfJV8082bTb+eJXqG+IC8tAVt+Pw/aIN2lhRMKUHrvuWFft+xj8tXDI0vaWPAwkeKV608V+9TJ8UFLiojS66ubNWsWfvOb32D58uVCKFVXV+ONN97AokWLvG7T1dUlTpLmZuVIk8lkEqdgkdvQOSXOEB1dxqCfS5M1Wnxg1qpdsISwjp6sO1qIxjUTvO7IEo3rjsY1h2Pd0fZ+mfCVs43MS0GiW+8MCZRAw5iojyelqwq5H/wSMLUDI+YC5z2M+kONLjHLvnB//b46SBosvbFuOYuood0oZgnKECZnWPAwkUav00ZFv1ivC57Zs2eLHp7LL78cnZ2dMJvNogfIV0ncgw8+iGXLlnW7feXKlaIPKFRWrVqFrnb6I6TBhi++Ql1pcMNH09vrMId2AE7swIrlyxEpaN3RRjSumeB1R5ZoXHc0rrkn625vV4YYMrGX0OYesRwsufEm3B/3Z8S1VymjHS59XkRPy6b7SA8TjXbkJHvKfiDR46nMTpa0FXEPD8NEVvDs3r0bt956K5YuXYqFCxeioqICd9xxB2644QY8++yzHre56667cNttt7k4PMXFxViwYAHS0lzt9UCPUNKX/fz58/H8sa041taEydOmY/74IOtrTe2wPXw34s0tWHTWKUBy4E2MoeC8boOhf8f9RfOaCV53ZInGdUfjmsOxbumwM7HDTreEtpCwWvDbzkcwQXsEXXFZiL/iVSAh3aXpvi+ipqMZOopOoqeh3SQ+Q1+Chx0ehomw4CG3hlweEjnE5MmTkZycjDPOOAN/+MMfRGqbO/Hx8eLkDn1Z92RHg7aNV5sszdAE/1yGdCCzBGgog6F+P5BRGPJagnrZHr7vviAa10zwuiNLNK47Gtfck3VH43tlesYue0JbDwTPqqU4petLdNkM+HTa33EufXeqSIdHNuEzgUNlgELwiM8w1eW+dqNZ3Eew4GEYV3q96I7KIbRa15fR6XT2JJi+qsc1hhJaQOSNV85rOLiAYRiGGVjUtXbhRJMSbTy+MPiKCsHmfwMbHxUX7zD9FAcT1O9NFdl0n8UlbUGT7SOaWkZSU7JdWgIfqGCYHgme1tZWbN++XZyIsrIycbm8vNxejkYx1BLq13nrrbfwxBNP4NChQyKmmhLbZsyYIWb59FUsdZc5yDk87tHU1bvDuCqGYRiG6Xt2nlBKGIfnJIuUtaA5+Cnw4e3i4trC6/Ce9TTX4aMAatWd9WwuaQt5+Cil6Hnt38lkd4dh3An6r9nmzZtx9tln26/LXptrrrkGzz//vOjRkeKH+NGPfoSWlhY8+uijuP3225GRkYG5c+f2XSy1WtLWFcocHiJ3nHLO0dQMwzDMgB04GkI5W81e4LVrAJsFmHw5vk37KXBoP5rcBI90eOTOOxM4FNVNHKhu7XYf9+8wTBgFz5w5c3yWopHoceeWW24Rp/5AnBqdZ5STn0OZxSOHj9Ln0AfTnxmGYRimN9glAwuKgixna6sFXroU6GoCik8FLvon0jdViLuaO03dyuacy7OYwJE/FylMPUdSc0Ibw7jT/4Ozw0y8OggsZIcnZxSg0QGdTUCL8secYRiGYQZUJHUwCW2mTuB/VwKNR5Rgnx+8BOjjxRwewt3hqbP38LDDEyzy51Ja2QKT24FbnsHDMN6JPcHT0x4efTyQPUK5XF0axpUxDMMwTN/R1G5Ceb0yd2lCoIKHKh3euxk4+iUQnw5c8RqQnCPuSkvUdxM89N3b0mkWl3O4hydohmYnITVBL4KX3MvaHDN4WPAwDGJd8MSpgifklDaCBqgRLHgYhmGYAVbOVpyViHR1yKVfPnsY2PG6Uvlw2QtA7hj7XdLhae5QBA7R0KaIH51Ww0liIaDRaDCh0HNZm0xpY4eHYboTc4JHxlJ39UTwOPfxMAzDMMwAGjg6KdDAgh1vAGsfUC6f/xdghCPQiPBU0ibTxaicTavlHtielLXtUhP1CKvVhoomLmljGG/EoODpYUmbs+DhpDaGYRgmCjhQ3YLdTjvIvvp3Ailn0xzbBLxzk3Jl1s3AyUu6PSZNOjydJrFDTnBCW8+RCXrODg8JSZPFBtKQ+akcBsEw7sSw4OlJSZt0ePYo9csMwzAM008hsXHpkxtxyRNfoLXLUV7mzu4KKXh8J7QlddVA9/piwNIFjFkEzL/X4+NkyRp9Tbaor1vXJhPaWPD0NKmNfl4WVUjKwIKCtATo1TRahmEcxKzg6VEPD4UWaA2AsRVoOhq+xTEMwzBMmGkzmtHQbkKHyYKjaiiBOzRu4liDct/wnBTvT9bZjJmHHoGmvRYomAR872lAq5SKu5Ng0Nm/c+Xw0To5dDSZXYhQGZaTgqQ4HdqNFpTVKsEFnNDGML6JQcEThh4enUGJpyY4uIBhGIbpxzi7OjLJyx0qNes0WcVoufx0L2LEYobu7WuR1nkctpQC4IevAvE+xJGHPh6OpO45FPgwfpAMLmh2TWjLZMHDMJ6I3Tk8PenhITipjWEYhokC2pwEj3QC3JEJX7kp8fYDgy5QXdpH/wftoU9h1sbBfNlLQHqR39e29/GogqdedXg4kjq8fTyc0MYwvok5wROnC0NJG5E33tHHwzAMw/Q5jz32GEpKSpCQkICZM2di06ZNXh/7/PPPi4hf5xNtNxCRc298CR6/JVFfPQlsfhY2aLBl6I3AoCkBvXZ3h0emtHFJW0+wR1OryXpc0sYwvolhh6engkc6PLvDsCqGYRimJ7z66qu47bbbcPfdd2Pr1q2YMmUKFi5ciOrqaq/bpKWloaKiwn46cuQIBn5Jm+IEuONzaOXeFcCKu8RF6zl3ozJjesCvbZ/F0+la0sahBeFxeHYdbxahFI6f38AU7QzTU2K3h8fUQ8FjT2rbRxE4YVgZwzAMEyqPPPIIrr/+eixZsgTjx4/Hk08+iaSkJDz33HNetyFXp6CgwH7Kz8/HQC9p89bDI28vdN9hrtwBvPFjqmkDTloM68yfBfXa3Rwee2gBC56eMDIvRQxSp/S7ow3tTj8/dngYxhN6xBhhmcNDZA0DdPGAuQNoPAxkDQ/PAhmGYZigMBqN2LJlC+66S3EhCK1Wi3nz5mHjxo1et2ttbcXQoUNhtVpx0kkn4YEHHsCECRO8Pr6rq0ucJM3NSsO4yWQSp2CR24SyrTMvfVUumtXnjM71eH+jWkZGHG9o9/h6MqEtPzXOcX9LJfQvXQaNqQ3WkjNgWfAQTGZzUGtOiVO+cxtoTozJZC9pS0/Q9vh998VnHWl8rXtsQQq+PdaMjQdqRAofkZes7xfvMRo/72hccyyv2xTkdjEneOiISFh6eCiGM3e0cvSLggtY8DAMw/QJtbW1sFgs3Rwaur5nj+c+yzFjxgj3Z/LkyWhqasKf//xnnHbaadi1axcGDx7scZsHH3wQy5Yt63b7ypUrhZsUKqtWrQp526oO4IHteqQabPjDyZ4P5G2q0FC2l/L45k68/8FyuI9qKT1C92tQcXA3ljfsgs7ahdn7H0Bm+wm0xA/C+tQrYPp4VdBrrj5GL6TFjr0H8W7XfrR1Kbsdmz//DLv7YA+kJ591X+Jp3akm5bN9ae0OcZ6gs2H9mv71/qLx847GNcfiutvbPUfseyPmBE9YYqmdgwuk4Bl7fs+fj2EYhokIs2bNEicJiZ1x48bhX//6F+677z6P25CDRH1Czg5PcXExFixYIPqBQjlCSV/28+fPh8GglH4Fy9p9NcD2bWgza3DeeeeJMj13Dq89BBw+IC5T6MBJp5/drVfnDzvW0qFAXDh3NiYMSoHuzR9D214GW2IWEpa8h/mZw0Jac9UXR/Dx8b3IyCvEjDNGA1+tg0GnwSUXel5rbxGOz7ov8LXuls3H8Pm7u7GvhXblrBiSnYpFi05DfyAaP+9oXHMsr7tZddgDJQYFT5hCCwiOpmYYhulzcnJyoNPpUFVV5XI7XafenECgL9xp06bhwAFFGHgiPj5enDxt25MdjZ5sX9WilHVYbYDRpkVKXPev9Xa37zvapiTXIdCoxLtG7a0ZmpMKw2f3A3s/AHRx0PzgJRjyRoe85kw1ja2ly4KmTqt9Bk9cXN/08PT0Z9VXeFr3lOIsl/0ZKmvsb+8tGj/vaFxzLK7bEOQ2MRdaELaSNiJPBhdwNDXDMExfQTvP06dPx+rVq+23UV8OXXd2cXxBJXE7duzAoEGDEE04hxC0qElo7rQ6xVKLbZpcgwsqm5TktkSDDhl7XwU+/5tyx0WPAkN75hikOYUWyP6dbI6kDgujC1KEWybhoaMM452YEzzS4TFarCLKMSyCp3afmEDNMAzD9A1Uavb000/jhRdeQGlpKW688Ua0tbWJ1DZi8eLFLqEG9957r+i9OXTokIixvuqqq0Qs9XXXXYfoFTxmvyltnqKpjzcoz7EoZR80H/xCufHMO4Apl/d4fc6x1PaENo6kDluJ/uj8VPt1TmhjGO/EXkmbwTFBmkRPAoUPqEfGqJ44JT6IjyR9CGBIAkztQP0hJcSAYRiGiTiXX345ampqsHTpUlRWVmLq1KlYsWKFPcigvLxcJLdJGhoaRIw1PTYzM1M4RF988YWItI4mnMWLV4dHFTz5afGoau7qNnyUrg/TVGBZ18OA1QxM+B4w5zdhWZ9d8HSYUC9n8HAkddiYWJiOXSeavc9QYhgmRgWP6vDIutcEgw6dJgsW/WM9bDZg9e1n2YMN/EJfnrljgBPbgJpSFjwMwzB9yM033yxOnli7lpryHfz1r38Vp2jHWbw0e3F4pPNDbgAJHvdZPPU1lXjO8DBSrC3A4FOAix9Xvt/CgPMcnlq1pC2LS9rCxsSiNLy6WbnMDg/DeCfmStr0Wg1kMIycxbN2bzWO1nfgWEMH9le1Bp/URnBwAcMwDNMDnttQhp+9tDXgHlOzxYrK5k7/JW1Gh+AhXASP2Yj5O27HMG0VmuMHAT94GTCEb8dZ9vCYLDbxHUtwSVv4mFCUbr/MgodhvBNzgofK1uxJbSblS+X9byrs95dWBBdzx0ltDMMwTDh4Zv0hfLijAhsP1QX0+OqWLlicelH9hRaMUQUP9ezYqKSBTu/fiuHt36DFlogvT30CSMlDOEmO00GnVY4yltW0ifMcFjxhY/ygNGQmGZCbGo/8VHbOGMYbMSd43GfxUDPn6j2OKNM9lS2hOTyc1MYwDMP0AOorJXYebwro8e6lad4cHtnDMzI/RZy3GS1o7jADGx4BvnkZFmhxs+nnSB0yGb1xkFGWtR2uUwQPl7SFDyrL//gXZ2L5z8+A3n2aLMMwdmLyf4dzNPUnpVXoVJ2ekByePNXhqTsgSgMYhmEYJhRkKduuE4EJHvfwAX+hBbkp8WIGDlFT9i2w+l5x+X7rNfjMOqXXmt6l4Gk3KmXkXNIWXvLSEoTDwzCMd2JS8DiGj1rs5WxzxuTaBY+w+gMlrQiIT1OSbUj0MAzDMEwImNXytJ3HAzvw5h4v7cnhMVms9oN6qQl6u6gxlm1U7h88C88Z54ve1vz03tlpTktwzUfilDaGYSJNTAuempYufLavWly+ff4YUWfc0G4SKTYBQ98Sso+HktoYhmEYJgRInBDl9e1oavfs1ngqaaOBoTL62dcMnuR4PQozEpQr1bvFWVPGBLv7E3BCaYjBBZLsFHYjGIaJLDEqeJQ/6h98WyGSY0bnp2DS4HQMz0nuWVkbBxcwDMMwIUCVBfR9JAmkrE0KHvoO8+bwyHI2OtBn0GntSV6JjXvFeWXCsF5P+JIlbbKknIIMGIZhIklM9/B8vKtSnF84uVCcjx2UJs5LK4MVPBxNzTAMw/S8nE2yMwDBI3t4xhSk+hU8VM5GyJK27LaD4vyQZqjL7b0teHKS40SQAcMwTCSJ8R4epXzggimK4Bk3SPnSKK0IMqmNo6kZhmGYHmB2cncC7eORDs+YAuVgXbOH0AIZSZ0Sr7c7OdloQpqlgWqyUWpWvv/spW69XNKWxYEFDMP0AbEpeNR6ZzmleJhayjZOOjxBl7SNU84bygCTaxMpwzAMwwQaSR2ow0OJbM2qmBkbgMND/TtS8IzWHlPuzCzBEXXWdqRK2rI5kpphmD4gJgVPnFNWvSxnkwO8iEM1reg0KfGZAZGSDyRmAjYrULuv292byurFczIMwzCMr8ACSVltm12s+Epoy0gyID8t3msstXwOh8OTgLGacnHZmjcex9XniZzgYYeHYZjIE5OCJ97geNvnTx5kv5yXqswooFLqfVUtQSa1jfNY1lbV3IkfPLURi5/bFIaVMwzDMAO5pM2g02BQegJoOsLuE81+y9kK0xORmmCwixv3sQqypE328OQkx2O8TnF4WtJH258nUj08PIOHYZi+IKZ7eKYPzcTgzCT77dRIKUsD9gTbx5PnOZqamkpJQB1r6EBdaxBx1wzDMEzMOTx6rRYTCtPF5Z3Hm/wGFpAzI8UMfde0qcM9vZW0abUaTNAfF5dPxJWI8Qy9LXjSVEFGZHFJG8Mw0SB41q1bhwsvvBCFhYVCILzzzjt+t+nq6sJvf/tbDB06FPHx8SgpKcFzzz2HvkKWrl19qpJO44zs49ldEZ6ktianuQgHqrmsjWEYhvEueMjhod5Sf308DmcmQczh0Ws1Hsva3EvaYLViuE0padvUrlQ40PZUGtdbsMPDMExf4zr+OADa2towZcoU/PjHP8b3vve9gLa57LLLUFVVhWeffRYjR45ERUUFrFbXeuVIsmT2MFHKNii9+xGtkIMLvCS1OQ+C21/dipnDs0NaM8MwDDNwkTN4aFbORNXh2XU8gJK2jERx8JFcHhqcTcEFg5TNXVPaVBcIjUeQYOtEl02PNVU0v6dR9PX0ZlQ09/AwDBN1gue8884Tp0BZsWIFPvvsMxw6dAhZWVniNnJ4+hKdlmqkPdv3jmjqZlELHfCXgExqazwCGNuAuORugocdHoZhGMa3w6PFxCJFseyvbkGH0YJED4M6T7iFDVAfjyJ4PDs8qdLhUQ/KHbQV4eujLb0eWNDd4eGSNoZhokDwBMt7772Hk08+GQ8//DD++9//Ijk5GRdddBHuu+8+JCYmei2Bo5OkuVk5ymUymcQpWOQ2gWw7NDNBlAZQ3Gd5bUvgXwRx6dAn50LTVgNzxU7YCk8SNze0Od7HvqrmoNYfzLr7C9G4ZoLXHVmicd3RuOZwrDva3m/UCx69RqSu5aTEo7a1SwzCPmlIps8eHkL28cioam89PKjeJc722IrRrqaR9mb/jnSXqOKOeozY4WEYZkAKHnJ2NmzYgISEBLz99tuora3FTTfdhLq6Ovz73//2uM2DDz6IZcuWdbt95cqVSEpyhAwEy6pVqwJ6XG68DhUdGrz44VpMzHRNvPHFaZoc5KIG365+HUezK8Vt2w9r7a1Su8rrsHz58l5bd38iGtdM8LojSzSuOxrX3JN1t7e3h30tjI+SNq1WVBZQH8/avTXYdbypm+CxWG2obFYcnsGZroLHfRZPtx4e1eHZZx1sf0xvOzxUVXHz3FGoaem0r5dhGGZACR7q1aE/3i+99BLS0xWb/pFHHsH3v/99PP744x5dnrvuugu33Xabi8NTXFyMBQsWIC1N6bEJ9gglfdnPnz8fBoP/xszVbTvw3rcVSCkag0Vzhgf8OtqP1wObSzFlkAGT5i0St33+zi6gQknEaTJpcMbc+fYI0XCvuz8QjWsmeN2RJRrXHY1rDse6pcPO9C5mp5I2gvp4SPDs9NDHU93SKUQPBRzkqiVi8nulW0mbWyw1qnbbHZ5ICR7itvmje/01GIZh+kzwDBo0CEVFRXaxQ4wbN070xxw7dgyjRo3qtg0ludHJHfqy7smORqDbTyhKF4JnX3VbcK9XoCS16er2Qadu19LlGhF6uKELJw0JzqXq6fvuC6JxzQSvO7JE47qjcc09WXc0vtdoxChjqXVK36hMatvhIZpaBhYUpCeImGmXkrYOHyVtZiNQt19c32sdYn9Mb5e0MQzDDPg5PLNnz8aJEyfQ2upo2N+3bx+0Wi0GD3ZY6v2J0JPa5PDRPR5jqYkDVRxcwDAMw3gbPKo6PGpwAQ3B7jK7HjijuW5y6Kj7rBufsdQkdqxmID4dxqQC+2NY8DAMM9AJWvCQcNm+fbs4EWVlZeJyeXm5vRxt8eLF9sdfccUVyM7OxpIlS7B7924xx+eOO+4QsdbeQgv6i+Apq2tDu9H1aFlAw0ebjwGdylG5ZvXLpyQ7yZ66wzAMwzCeQgviVMFDIoRm45itNuyrbPWY0OYsVPz18Ij71XI2ShUtVIduUxBpfjonpzEMM7AJWvBs3rwZ06ZNEyeCem3o8tKlS8V1mrEjxQ+RkpIi6scbGxtFWtuVV14pBpf+4x//QH8lN5UScuJgs9HRtSAcmcRMIFUZ5IaavS4Oz0lDM+2zeBiGYRjGV0mbCC5Q5/G4DyB1nsHTXfA4HB4qHW9zLmlTE9qQP17M3iGoByhe3z32mmEYJqZ7eObMmSP+iHrj+eef73bb2LFjoy7ZiFye9ftrRVnb1OKMwDekeTwtFUoSTvEMez319KGZeGvrcZ7FwzAMw/gtaSMmFKVhw4Fa7DweiOAxdHN4usxWe/qbKGmTg7HzxqPQlhixwAKGYZgB38MTrciyti8O1oXYx1MKq9VmL2kjwSNrr4Mqk2MYhmFiaPCoY9j15CLlYNuaPdViAGn3GTyKS+OtpE2WsxHJcc4lbeMxNEspaRuqllszDMMMZFjweOHciUpD5/vfnMCG/bXB9/HUlKLVaBZlcURJdrJ94NrB6rbwL5hhGIaJWkzW7g7P3LF5ok+noqkTT352sJvDU+TB4ZEH2Qh7OVucDlpjC9CklpvnjcP3pg/GreeMEieGYZiBDgseL9Cgt8WzhorLv37zW5cjZT7JG293eJralS+eeL0WCQYdRuSliOsHaji4gGEYhnFgMsseHsfXcmKcDr89X6kaIMFztL5d9Og0qy7OID+hBfJyCt1Xo6aHUp9pUpZIdfvl/NEYnqt8LzEMwwxkWPD44NfnjhVToal84KGPHFHTPskdo5y3VqGtsUZcTEtUjryNUgXPfo6mZhiGYZwwW7uXtBHnTSzArOHZoh/n/g9LhdtDpCcalL4clTQPoQUukdRVu1wPyjEMw8QQLHh8QKk2D10yWVz+75dHsDGQfp74VCBdGehmqtxt/2JyETwcXMAwDMM4IcMFZCy1hNLa7rloAnRaDVbsqsRrXx/1ODtHzuEhkSODhWRJWwrdV6327+Sz4GEYJvZgweOH2SNz8MMZQ+ylbQEFDqh9PNqaUpcjbyPzUsU5J7UxDMMwzhjtJW2uDg8xpiAVV5+qlFg/s6HMY7qa7OGhVqA2NeDA4fDoXBLaGIZhYg0WPAHwm0VjUZiegPL6dvzpY2W+jk9yFcETV7/P1eHJVxyeI3Vt3SZnMwzDMLGLo6TN89cy9dtkqcE3RJFTQhuRYNBCr9W4lLXZe3jidFzSxjBMTMOCJwDoyNmDamnb818cxjvbjvveQP1CSW7a59LDk5caLxpL6QhcWS0ntTEMwzCuJW3eBA8dOPu/hWqPqAeHh0rf3IMLZEnbIF0z0FEPaLSOPlOGYZgYggVPgJw1OhdLZpeImOnbXtuOD7+t8FvSltF60MXhoS+kkRxcwDAMwwQwh8edy04uxhR1ELacFeeMY/ioyaWkbZj1iPKArOGAgQeNMgwTezgiXhi//P788eKI2Wubj+Hn/9smaq0XTlDm9biQQ0fQNEgyNyIbTXbBI4MLtpU3ch8PwzAM003w6LXej0NqtRr899oZ2HmsCbNGZHe7Xzo8zR1mF6dniPmw8gAuZ2MYJkZhhycI6Mvmwe9NxvemFcFiteHml7dizZ6q7g+MSwIyS8TF0dpj9vQcYhQHFzAMwzBumGVKm9731zJ9n5w2MkdUDHgVPKrDI0vaCrqUoAMWPAzDxCoseIKEokEf/v5kXDB5kKi5vuG/W/HFgdruD8xThsWN1hxzcXhGqsEF+6t7Z/joliMN+P07O9HU4ZjFwDAMw/RvjAGUtPnDUdJmdilpy21Xyqs5kpphmFiFBU8I0CTsv14+FedOKBBfUn/9RAkn8CR4xmiOIi3RUTk4Up1qTaEFZvULLpw8uma/mBm0cldl2J+bYRiG6d3QAl8lbf5wDy0gwaOFFRltquDJmxCOpTIMw0QdLHhChJJ0bpgzQlw+3tDR/QG5iuAZRSVtTg4PDYtLNOjEl9uR+vawr6u+zehyzjAMw/R/5AEwg5+SNl/I8mnnWOpiTTX0lk5AnwBkDQvTahmGYaILFjw9gGKmiZrWLlgpa9pDUhuVtKXF6136gHozqU2WsnFJG8MwTBSmtKmzdELBUyz1WM1R5U6Ko9bqwrFUhmGYqIMFTw/IVQUPuTUN7W6OSvYomG1apGvakWWtc7lLCp6DNeEXPM3qFx0LHoZhYo3HHnsMJSUlSEhIwMyZM7Fp06aAtvvf//4nQgAuvvhi9Nc5PMEJHkcsNZVVC7icjWGYGIYFTw+gL6ZsdfJ1dUuXy32dMOCILV9cTpf1027OULjLzmw2Gzs8DMPEJK+++ipuu+023H333di6dSumTJmChQsXorq62ud2hw8fxq9+9SucccYZ6Bex1OEMLeg0Y7RWCh6lzJphGCYWYcHTQ/LSEsR5VXOny+0UC7rPNlhcTmxwDTWQPT3hFiXtRouIy+6N52YYhunPPPLII7j++uuxZMkSjB8/Hk8++SSSkpLw3HPPed3GYrHgyiuvxLJlyzB8+HD0i1jqsDg8ZnEArNXoVNLGCW0Mw8QwPHi0h5BbU1rR3eFp7iDBU4zz8DW0NaUeBQ89Jpw4ixwWPAzDxApGoxFbtmzBXXfdZb9Nq9Vi3rx52Lhxo9ft7r33XuTl5eHaa6/F+vXr/b5OV1eXOEmam5vFuclkEqdgkdvQeZfZIi5rYA3puYgkveIONXcY0dTWiTibESUaJbHTlDWaXiik5/W25miC1x1ZonHd0bjmWF63KcjtWPD0kPw0pTyt2s3haeowY59VcXhQvcflPjmXJ9yihAUPwzCxSG1trXBr8vOVMmIJXd+zx/Xvr2TDhg149tlnsX379oBf58EHHxRukDsrV64UblKorFq1CnUNFCigwfYtW9B1yC0EJ0AOi/FuelQ3tuC9j1ZihOYE9BorjLpkfLRuK+BhWGlP1hyN8LojSzSuOxrXHIvrbm8PLumYBU8PyUuVJW3dHZ69akkbavZQg439y0YKHhkwEC6cHSMWPAzDMJ5paWnB1Vdfjaeffho5OTkBb0cOEvUJOTs8xcXFWLBgAdLS0kI6Qklf9vPnz8djB78G2lpx2qwZmDU8G6FwsKYNf935OcwaA2bOPh3btv1R3K4vmoxF558f0nP6WrPB4Bi50N/hdUeWaFx3NK45ltfdrDrsgcKCJ1wOT0v3Hp7DtgKYoYfe2Ao0HQUyhoj70tQ662BL2srr2nGkvg1njMr1eL+zyKHnpqhsisFmGIYZyJBo0el0qKqqcrmdrhcUFHR7/MGDB0VYwYUXXmi/zWpVQwP0euzduxcjRihz1pyJj48XJ3foy7onOxq0rVntv0yIiwv5ubJSEuzpbB0WYIwaWKDNnwhtmHeEevqe+wped2SJxnVH45pjcd2GILfh0IIekuvF4SHxQWKnOq57WVuoJW03vbwFVz+7CQeqRd1CN5yfj747W7rC6yAxDMP0R+Li4jB9+nSsXr3aRcDQ9VmzZnV7/NixY7Fjxw5RziZPF110Ec4++2xxmVybSGNSBZchDClt9PefyqwdkdSc0MYwTGzDDk+YHJ4aD6EF4vbE4Sg0HgaqdwOjF7gIHjoKR9O19QGk8lD62t5KReiU17djZF5qt8e4l8jRGuRrMQzDDGSo1Oyaa67BySefjBkzZuBvf/sb2traRGobsXjxYhQVFYk+HJrTM3HiRJftMzIyxLn77ZHCZO75HJ4EgxZ6rUa4RRVNnZgvI6nzeQYPwzCxDQueMMVSU0kbxYDS8Dpnt6UxZSTQtEbp43FLaZPxoZnqLB9fUOy1HExX3+bZGXJ3jOh65I9TMgzDRJ7LL78cNTU1WLp0KSorKzF16lSsWLHCHmRQXl4uktv6K3IOT08ED33/UDR1Q7sJ9bVVKNTUK3eww8MwTIzDgqeH5KYoDg+JEfqSyVLFS3OH4ra0ZYwCjpMi2m3fhr7QkuJ0Ym4OiZJABA+5OpLGds8DS917gji4gGGYWOLmm28WJ0+sXbvW57bPP/88+ofg6VnfJZW10XeRRj3IVq/PQ1ZCeljWyDAME63038NdUUKcXotsVbA4Dx+VYsOYOVq5oWYfYFXmLLgmtQUmSpwFT30bCx6GYZiBhHTwe+LwOA8fTW7aK86rEvp2oCrDMEx/gAVPGMhNlUltXd3EhiZ7OBCXCpg7gI2P2e9PU5tLAxUlR50EDx2984T7czV6eRzDMAzTvzDbQwvCI3iy2g6K8/qUUWFYHcMwTHTDgicM5Kt9PM4Oj3Ru0pISgPn3KDd+cg9weIOrw6OWvgUjeLyWtKmvmWigAXbs8DAMw0QD1P8pHR59GEraiGLTYXHenDoyDCtkGIaJbljwhIE86fB4KGkTwubka4HJlwM2C/D6EqC5AmmJ+qBESSAlbfK5hmQpE79Z8DAMw/R/5Aye8Dk8NozRlIvr7Rljerw+hmGYaIcFTxgdHueStmZnwUPJbRf8DcibALRVA6//CBkJrmlu/iiv7/BbqibdomIWPAzDMFGDDCwg4nooeKhcOh8NSNe0w2zTwpzFJW0MwzAseMJAnjqLR5a0Wa02+9BP2auDuCTg8v8C8WnA0S/x/bqnAg4taDeaUdvqEFP1XkrapMApzkpUnpsFD8MwTL9HlrOFp6RNj7Hq/J0y2yAkJikHwBiGYWIZFjxhIC/V1eEhsWNTv79k6ZogewRw8RPi4qnVr+J87ZcBuTDHGhR3Rx3xI3p4qObbGaPZig6TkgLHJW0MwzDRAw2gltDg0J4KHlnOttdWjNR4nj7BMAwTtOBZt24dLrzwQhQWFoohZ++8807A237++efQ6/ViINxAdHiqm7tcnBWaeh2vVwIE7Iy7AJj9C3HxYcO/kNh4wO/zH1UFz/CcZPvRwFbVQZI4O0XFmYrgaezw7AQxDMMw/QejPZJaYx9e3ZPQgjHaY+LyXutgpKipbQzDMLFM0IKnra0NU6ZMwWOPOSKWA6GxsRGLFy/GOeecg4Hbw9MpnBeXwAJPzP09qrNnIFnThR8f/z3Q1RKQ4BlTkCpElKc+HvmadHQvMzm4yGuGYRgm+iOpHQ7PUbvDkxzHgodhGCbov67nnXce/vCHP+C73/1uUNvdcMMNuOKKKzBr1iwMNHJT4u3OC83IkQ6PvX/HHZ0epbP/hkpbJorMR4F3b6ZcUq/Pf1QNLKAwgsykOI9JbU1OrymFVhPP4WEYhun3mMy2sJSzEalxGozSHBeX99iG2OfyMAzDxDIR+Uv473//G4cOHcKLL74oxJI/urq6xEnS3Nwszk0mkzgFi9wmlG0Dgb6iMpMMQuycqG9FXasSXpCWoPf6mobUXNxkvBWvxd8H/e53YPniUVhn3OBx3eV1beK8MC0eGYkGVDR1oralAyaTUuJGNDi9ZpJeY+8l6uoyQhuGL9H+8ln3FrzuyBKN647GNYdj3dH2fqPZ4YnT99zhyTUdR7zGhHZbPI7acpHCPTwMwzC9L3j279+PO++8E+vXrxf9O4Hw4IMPYtmyZd1uX7lyJZJ6kDizatUq9BYJoF4dDT5YswGNQqvp0NlSj+XLl3t8/Ik2YKttNB6yXInf6v4Dzaq78eXhDtSndJ+ZsOdYrXjuygM7Yekg8aLF2i++Rut+hyu0pZZu18HU3oSNn60WP1oyjd764CMk9cH3XW9+1r0JrzuyROO6o3HNPVl3e7tjBhjTuylt4Shpy2xV+kL32YpggxbJLHgYhmF6V/BYLBZRxkbiZfTo0QFvd9ddd+G2225zcXiKi4uxYMECpKWlhXSEkr7s58+fD4PBS5lZD3mjZgsqDtShZOxk4fTg0D6MHFKERYsmeXw8uTQPfbsOz1nOxZ2TWqHb/RZOr3gG5mvXACn59nWvXLkKjSYSU1ZcsvAslH9yAPuaKjFk9HgsmjXU/nwNm44C+0sxrKgAF10wFb/b+gk6TFaccvocDFVT2yJBJD7r3oDXHVmicd3RuOZwrFs67EzvYVRT2noaSU2kNe0T53utQ4RjFA7XiGEYJtrpVcHT0tKCzZs3Y9u2bbj55pvFbVarVTT2k9tDjs3cuXO7bRcfHy9O7tCXdU92NHq6vS/y05XZN3XtZnQYlS+vzOR4r6+Xk6Z8sdH3XOd5f0VyzW5oavbA8M5PgMXviT4fosUEdJqtoKq0ITmpyFL7hVo6LS7P3WZ/zThxe3piHDpMnWg32fpk56w3P+vehNcdWaJx3dG45p6sOxrfa7RhDqPDk9CwV5zvsw3m/h2GYRiVXj30Q27Mjh07sH37dvuJwgvGjBkjLs+cORMDhXyn4aOOAAHvXzaJBp29QbXJEg9c/iIQlwoc+RxYfY/9cXVqK9Og9ERxpI4Ejafho86hBYQ9uICT2hiGYfo1JtXhMWh7/pWsrSkV53tsxRxJzTAMoxL0X8PW1lYcOOCYHVNWVibES1ZWFoYMGSLK0Y4fP47//Oc/0Gq1mDhxosv2eXl5SEhI6Hb7gBk+2tyFeDU6Os1bLLUYIqoRoqSuzShm6BQWjAIufgx4bTHwxT+BwacAoxahtlMRRcVZioNE4QiEKJtzQibDSaHDgodhGCY6MFtVh0cNnAkZYzs09YfsJW15HEnNMAwjCPpwEpWoTZs2TZwI6rWhy0uXLhXXKyoqUF6uTHmOJewOT4uTw+ND8BDd4qPHfweYpZT+4Z2fAXX7Ua86PEPUPhwZS93gLZZaCh5VGLHgYRiG6d+YzGoPT08dnloqZ7OhEWmoRRo7PAzDMCpB/zWcM2eO6MHxxvPPP+9z+3vuuUecBhq5Tg6PPEbndfCoSqonF2beMuDENlHapn9zCVo6fgUgySF41JK2bg5Pp2eHx31AKcMwDNO/MKkOT1xPe3iqdouzI/oSkeyZygltDMMwAo5vCbPDU9PShUa38jJvyPubO82OGyms4Pv/FkltFGLwo7ZnxRE7GjrqUtLmxeFxFzyy1I1hGIbp5z08PS1pq1YEz4n4YeKcI6kZhmEUWPCEidzUeHu86LGGDpcAAW/IUINuZWep+cClz8Om0eEc20Ys1q10EjzS4fFW0qY8J/fwMAzDRJfg6XFJmyp4ahJHiHMuaWMYhlFgwRMm4vU6u/tiVOuxZR+NN3y6MENPg/Hsu8XF3+lfxPDOXS4lbV1mKzqMFvvDmzsUl4hDC3qPLrMFda1qUxXDMEx/i6VWS9oaUkaKcy5pYxiGUWDBE0by05Q+HomvWOpARMmRkYvxgeVUxGksSH//eqC1BslxOnudt4ymtlpt9h4eGVqQwaEFYefON3dg5gOrcaC6pa+XwjDMQCxp68ng0fZ6oLVSXEwpVgZej8hNCc8CGYZhohwWPL1Q1kbQiJ0UP0fX0vz02Rxt7MSvTdejXDsYmpYTwBtLoLFa7GJG9vG0Gs2QORKyjE4+N4cWhAdy0z7cUSHiY7ceaezr5TAMMwBDC3rk8KjlbMgYgh+dPQmrfnkmLj15cJhWyDAME92w4Oklh4cEB83aCSy0wIvgqW9HGxLxVME9gCEZOLwe+PQPyLIntRldYq3j9VokGHQuz80OT3jYdLjeXqp4vFHp0WIYhglrD09PHB61nA15E6DTajAqP9XvdxDDMEyswIInjOQ5OTz+EtoCESVH1fADff5Y4DuPKjdu+CvO0Wx2iab2NPeHU9rCy/p9NfbLJ1jwMAwTRkzmMMRSS4cnb1yYVsUwDDNwYMHTSw5PIIJHlp/5EzwioW3i94BTbxLXb276M0o0FfaSNvcZPM6XW7rMsKjlEkzobDhQa798ookFD8Mw4cNslT08YRA8+RPCtCqGYZiBAwueXnJ4/EVSu7owTnN4nDharwqezETlhvn3AsWnItHahicMf0NLS7O6vXfB43w/ExrVzZ3YU+kIKjjR2Nmn62EYZmBhUlPaQi5poybO6lLlct74MK6MYRhmYMCCJ4zkBevwqDNzPDk8NpvN4fBIwaMziPk8bYYsjNMexRl77xdfdPaSNqdUODpSSIluhByEyvTM3clJibf38FAyHsMwTDh7eEIuaWs6BnQ1A1o9kK1EUjMMwzAOWPD0lsOjihlfSFHUYbLYG+IllK7W2qU4P4Ol4BFPPAifTnoIZpsWU+pXAJuf7TaDx/35ObigZ6zfrwie751UBOoBpp9VnVpOyDAM0+cOjyxnyxkN6JVQG4ZhGMYBC54wkpfmLHj8OzypTmVv7klt5fXtyvMYbPbkNUlX0Wl42Hy5cuWjO5FYvd2j4JFrYMETOuS0ScFz9pg85KcqLh4HFzAM0296eKqUwdRczsYwDOMZFjxhJF6vs8/ICaSHh6JD5SRsd1FytEERPNmus0wFFEv9lOUCfB53GmA14YK9dyITzd1EFjs8PYd6d2pbu5Bo0OGkoRkozGDBwzBM7zg8IQsee/8OJ7QxDMN4ggVPmJEOQCA9PL6Gjx6ubRPnOfHde0UUUaXBPZqfAVkjkGGqwj8MjyIjwfXHKcUXC57QWb9fiaM+dXiWELSFGUp5Ic/iYRgmXJjUkmZDT0vaOKGNYRjGIyx4wszIvBRHlHQAeHNhDtYogicvsbvgkYNHj3fogctfRJcmAWfodmJW+dMen5tT2kJHlrOdMSpXnBepgoeT2hiGCRcmaw8cHosJqNmrXOaSNoZhGI+w4Akzy74zAf9ecgrOGJkT0ONluEFzp2s09YHqVnGe75RXIMlIUgRPu9GCzqwxeDz1FnF9/IF/AXtXdBM8je3cYB8KnSYLNpXVi8tnjFJ+ntLh4ZI2hmHCndKmD0Xw1B0Upc2ISwHSi8O/OIZhmAEAC54wQ9HF1Nyu1WpCdnioUf5gjSJ4CpK6OzwUP039PzLN7QPb6XjevEC58+2fAPVlXp+bCZyvD9ejy2xFQVqC3bmzCx4ePsowTJgwqz08caGUtFXLwIJxgJa/0hmGYTzBfx37GE9lZxVNncK90Ws1yHEEv9nRaDTIVPtzGtqNwh2633wV2vNOAjqbgNeuBkwdLHh6yAZ7OVuO+MwJDi1gGKbXHJ5QBEuV2r/D5WwMwzBeYcHTx8g0N2fBI92dIVlJ8FbhIMvaSPCQoDFBj6YLngaScoDKHcCHv2LB00PWqYLndLWczbmHp7bVKEreGIZheopZ9vDotT1IaGPBwzAM4w0WPH2MJ1Ei+3dG5CZ73S5LFTyVTZ32oaUpeUOB7z8HaLTA9hcx5sRb6nO79gcx/qlp6UJpRbO4fLpTPxb9vJLidHYnjmEYJlwOT49K2vJZ8DAMw3iDBU8f42k4qHR4fAkeGTl9uE6Z10MtPclxemD4WcDc34vbRm2+F5M0h9DEoQVB8+WhOnE+oTAN2SmOukIqbePgAoZhwokx1JI2YxvQcFi5zA4PwzCMV1jw9Jcens7uDs/wHB8OjxpNfaSuzS6c7EEJs38BjFkErdWIJ+L+BnQoSWNM4OytbBHnkwdndLuPZ/EwTP/kscceQ0lJCRISEjBz5kxs2rTJ62PfeustnHzyycjIyEBycjKmTp2K//73v+jL0IKgS9qq9yjnyXlAcmDJoAzDMLEIC55+WNImZ/D4dnjiXAaUyl4gAR0lvPgJWDJKMFhTiwds/4TJxH08wbC/WhE8o9R0NmeKOLiAYfodr776Km677Tbcfffd2Lp1K6ZMmYKFCxeiurra4+OzsrLw29/+Fhs3bsS3336LJUuWiNPHH3/cZyVthgDTPe1wORvDMExAsODpY+xzeNQ+GxI+1D9CDPPh8GS6lbRJ4WQnMQO2y/6LDlsc5ui+gWnNH3vrLQxI9qsu26j87oKnMJ1L2himv/HII4/g+uuvF6Jl/PjxePLJJ5GUlITnnnvO4+PnzJmD7373uxg3bhxGjBiBW2+9FZMnT8aGDRuiyOHhwAKGYZhAUPa2mX7j8MhyNpr9kprg/ceTqZa0ye26CR764RZOxlJcjwfwGBI3/gXQWYE5dwJ6D1nXjJ0uswVHVCE5Oj+12/2OHh4OLWCY/oDRaMSWLVtw11132W/TarWYN2+ecHD8QbPP1qxZg7179+Khhx7y+riuri5xkjQ3K8Em5KCH4qLLbWQPD6yWoJ5HV7lTHLU0Z4+BLUIuvlxftFUN8LojSzSuOxrXHMvrNgW5HQuefhJaQD08Vqtj4KgcdOmNTLWkzfE8nn+UnyXOw1Oth/ET/YfAhkeAfR8D330CGDQlbO9hoHG4th0Wq00IzrzU7uKQQwsYpn9RW1sLi8WC/Px8l9vp+p49ap+LB5qamlBUVCREjE6nw+OPP4758+d7ffyDDz6IZcuWdbt95cqVwk0KldZ2+luiwaYvv8CJHYFvt/DYdlCB7ef7G9B4YjkiyapVqxCN8LojSzSuOxrXHIvrbm9XDkwHCguePkb23thsQKvRjIMBRFITWcmujo4nh0fe/kDjlThtzrmYuHWZUvP99FzgzDuAM24HdJ63i2X2VTn6d+TAUWeKnEIL6Miwp8cwDNP/SU1Nxfbt29Ha2orVq1eLHqDhw4eLcjdPkINEj3F2eIqLi7FgwQKkpaWFdISSvux1+jjAaMLZZ57psYzWI201MGxrhg0anPadJUCc7++McCHXTMLQYIie7w9ed2SJxnVH45pjed3NqsMeKCx4+pgEgw7xei26zFY0tZsCdnhkaIG7U+SOFEIHc87BxJ8tAj74JVD6HrD2QWDPh8B3nwTyJ4Tt/Qyo/p287uVsRH56PEjj0M+svs3oElvNML3F7hPNeGPLMdwyd6S9pJVRyMnJEQ5NVVWVy+10vaCgwOt2VPY2cuRIcZlS2kpLS4WL403wxMfHi5M79GXdkx0Nkzp4NCE+iOep3y/ONJklMCR3T5PsbXr6nvsKXndkicZ1R+OaY3HdwW7DoQX9rKzNMXTUt+CRg0ftz+Gc0uZhXo/o9aHY0sv+A1zyLJCYCVR+C/zrLGD9XwALDyeVHJAJbV6OtMbrdchVRQ738TCR4l/rDuK5z8vw3jcn+nop/Y64uDhMnz5duDQSq9Uqrs+aNSvg56FtnHt0IoVZprTpgvhKrt6tnPMBK4ZhGL+w4OkHSBeG0tnK69sDcnhIJDlXUvkqaSPIPRLQRpO+D9z0FTD6PMBqAlbfCzy3AKjZi4EG9eLc8fo3eGC5mmYUAPur/LtsRZk8i4eJLA3q/+GKJhbZnqBSs6effhovvPCCcGpuvPFGtLW1idQ2YvHixS6hBuTkUDnFoUOHxOP/8pe/iDk8V111VcTXbpIpbaEInrxxvbQqhmGYgQOXtPUDpCj59lgTqLIhNV6P3NR4mM3eXRedVoOMRIN9J8hfSVuj05wfQWo+8MNXgG9eAT66Ezi+BXjyDOCc3wOn3gRodRgIbDnSgNe3HBOXb5s/WpQQ+puHUabONvKU0OYcXLCtvJGDC5iI0dal/D2obY28AxENXH755aipqcHSpUtRWVkpStRWrFhhDzIoLy8XJWwSEkM33XQTjh07hsTERIwdOxYvvviieJ5IQv2bZrWkzaALoh+wSgoejqRmGIbxBwuefkCaGj+9tbxBnI/w0izvKalNCh5vDk+ah8Gmdug1pl4BDDsLeO8W4OBqYOXvgNIPgIsfB7JHINpZtbvSfpkctOIs30lKFEdNOx/JcToMSlcGjHpCBhew4GEiLXjknC6mOzfffLM4eWLt2rUu1//whz+IU1+jmjsCfaAOj9XqmMHDJW0MwzB+4ZK2foAUK+QYBFLO5t6f4/wc3p7bo+CxP6gIuOpN4MK/A3EpwNEvgSdmA1/9S/lijVIoQW3lbkcTcyBHxg/UKO7OyPxUn6KzUBVDJ5pY8DCRoZUFz4DEWfDEBSp4msoBUxugiwOyhvfa2hiGYWJW8Kxbtw4XXnghCgsLxQ7hO++84/Pxb731loicy83NFbGd1ED68ccf92TNAw53UeIvsECS5ZTUJF0in6EFvqCd++k/Am78Aig5AzB3AB/9HxqePA/bvv0G28obREqUvRcoStLW5ABRorbVGNA2MpLaF3IWz3EOLWAi7fBwSduAFTwBl7TJcracMTxagGEYpjcED9U9T5kyBY899ljAAokEz/Lly8Uk7LPPPlsIpm3btgX70gMW9/6bwB2euIAdnmZ/gkeSORRY/B6+nfI7tNvikVn9JUa9uQCv/es+LPrHOsz642p8fqAW0cDKXY5ytkAdnoPVbUEJHi5pYyJFW5dFnFMUOoVxMAMDs9W1NzMgaJ4akc/9OwzDML3Sw3PeeeeJU6D87W9/c7n+wAMP4N1338X777+PadOmBfvyAxJ3seJv6KhHh6cnJW3uaLV4om0udhuz8PeEpzEVpXjQ8CwuNGzG7Z3X4aaXtuLtm07D8ACdqL5ilVrORv04bUYLagMoBTqgzkHyN/xP9vBQeVGX2SKiqhmmtzCarTCq0cUkdhrajcjh+U8DAqldqZwt4CHGsn+HE9oYhmH6Z2gBzTloaWlBVlaW18fQHATnWQhymipNZaVTsMhtQtk2EiQZtC4lDYNSDS7v1du60+KVneykOB1gtcBktXh4jNbubjS0diAl3v+PnJLK1u+vRautAOar3oWl4lVo196P08zf4JPEX+Nu49W49t96vH7Dqd3EWn/5rCubO/HNsSZRqbdoUgFe33Ic1c0dXtdFt1NpySE1oW1YVqLP95BsABINWnSYrDha14qhfsIQeov+8nnHwrr7cs2N7a7lmBUNbUhX/2/39rqj6WcUjZhVwaMPKaGNAwsYhmH6peD585//jNbWVlx22WVeH0PzEZYtW9bt9pUrVyIpKfQdS5q50B85UEdfdIp4yY6zYuXHKwJa97EqZbs4mEXJoLfI05wEHWo7gb+9ugon5fgvhTnQRA3SeqTobTi640sc1wxFyqhlmHbkKWS1H8SfDf/CJy2bcPOjP8Zl49Lhqc+2rz/rDZXKZzM02QZLXbm4vGP/ESxfXuZ1m7pOZR5GnNaG7V98im/97H+k6XXoMGnw9sefYXR635YY9fXnHUvr7os10++m85/r5Ws24FCGLSLrbm939MExvdfDE/AMHrMRqNuvXOaSNoZhmP4neF5++WUhZKikLS8vz+vjaDgcDZFzdniKi4uxYMECEXwQyhFK+rKnXiKDof81eGaX1eO5fZvF5SnD8rFo0dSA1m3YXY3/HdqOvIxULFp0mtfn323Yh6fWH0Z1XCEWLZridz1/WrkPwGGcM6EQF5w/yXGH9RpYvnwMms8ewjxsw8ldd2Jlw+248KpblNCDfvRZv/7CFtpNxKWnjRblZ28d/hb61CwsWjTD4+Np3X959RNxeXRBOi44/1T/r1GzBVUH6lA8ZjIWnVSEvqC/fN6xsO6+XPPeyhZg20b79WHjpmDRtMKIrFs67EzvoFYqBh5YQGLHagbi04G0vvm7wzAME21ETPD873//w3XXXYfXX38d8+bN8/nY+Ph4cXKHvqx7sqPR0+17i8wUx7yX0QVp3dbobd2zR+fhlJJMXDSl0Of7umBKkRA8a/fVwmzTIpFK4Hywbn+dOJ87Lt/teQ3AWb8Cxi5C0yvXIaNxFy4rvxflz36OIVf/C0jJ9bvmSNDcacJXZfXi8rmTClHdrJRH1reZfK6pUj2QTQNHA1n74ExyG+tQ1eL7eSNBf/3dHojr7os1d7mlwzd0mINeQ6jrjrafz4B3eOzlbOPsB5oYhmGYfjCH55VXXsGSJUvE+fnnnx+Jl4wqnPtgAo2kltu9fsNpuHpWic/HTSpKFy5Hh8mCz/bV+HxsRVMH9lS2iO/RM0c5BIwL+eORfstn+GroT2Gy6TCkajXw+Exgl++I8kChEID/bSrHD57aiBU7XZPWAmHt3hpRmkbhD/R55qbGBxTnW9mh7DyM9BNYIOGkNiZStKoJbRKexRPDgqdaFTxczsYwDNN7gof6b7Zv3y5ORFlZmbhcXl5uL0dbvHixSxkbXf/LX/6CmTNnorKyUpyampqCfemYEDyBRlIHAyX/nDexQFz+aGeFz8d+tlcRRFOLM5DplALXDZ0B4354Py423odSazHQXge8fg10b18Pg7kl5Dkjz6w/hLMeXos739qBLw/V44UvDoeczjZ/vPKec9U0q5ZOMzpN3YMdJJXtiuAZlZcanOCJ0PDRutYuEQlOA1WZ2JzBI+FZPDEcWiAFTx4LHoZhmF4TPJs3bxZx0jJSmnpt6PLSpUvF9YqKCrv4IZ566imYzWb87Gc/w6BBg+ynW2+9NdiXHrBQcho5MBQz3RuChzhvkrLzv7q0WjgovtwRYs5o7z1WkrQEAzpyJuAi4/04PP5GQKODdvfbmFv6G2j2fRTU+t7edgyzH1qDP3xYKhLWZJrc0Yb2oON71+6pFpcXTMhX1pmot08wr2vzPHyUon6rVd0yOmCHRylFPNYQGcHz6zd34MpnvhJCkIktWt0FDzs8AwaLTRE68m9U4CVtLHgYhmF6rYdnzpw5Po8wP//88y7X165dG+xLxBzkwCz/+Rmw2GxIMPTOPJdpxZnIT4tHVXMXNuyvxTnjFDHgLhY2qENFzx7rpZzNjSmDM3Copg3vZP0Yv7juUtjevgEJtfuA168G9v0QOPdBIDHT53OQ60I78/T6JdlJuOGsEZg9MgdnPPwpKpo6YbZYoQ9wZ+DLQ3Vo6TKLMrapgzPsn292Spx4LprFI2foOHOssQMmmwbxeq3am+OfkWr54ZG6NnQYLX57o3rKrhOKK1pe34ZZI7J79bWY/unwZCYZ0NBuYsEzAEMLAnJ4OpuBJvWAIs/gYRiG6V89PIx/0pMMLoNEw41WS2Vtg8Tlj7z0xWw50iCOJOekxGFiYXpAzzt5sPK4b481AUXTYb52DfbnLYINGuCbV4DHZwH7lfQzb+w60SzETnZyHFbfPgc/mDFEiJI4vVY4LyRUvLGnshnPf16GO17/Buf/Yz2ue0FJu5s3Ll+8Z4kc0kjziDxxoFoZODo8JzngaeckquizosGBtI7ehEQhOV8E7fD2hKrmTvzif9uwrbwhTKtjIiV4SnKSff4eMwO8h6dmj3KeOghI8j7LjmEYhnGFBU8Mca7ax0M9LjRc1J21+5RSsDNH57qIBV9MVl2Ub481Ks6fPgG7i34AyzUfAlkjgJYK4KVLgPduAbo89/ZsP9po7xuSYoNef7DqxByt91zWdqimFef+bT3ueX83Xt9yTBFOFqsQIVfOHOLyWLrNt+BRBo6OzFN2KAOBnKPxqjCk1+5NjjW0i5lKRGMPBc9LXx7BO9tP4IYXt6Cpg4dKRlNowbDsZLvopYMEzAASPNoAvo6rdinnXM7GMAwTFCx4YohTSrLEjj/t5G48qERPO7N2j9q/M8Z//45kQmEa9FoNaluNOOHkxNgGzwBu2ADMvEG5Yet/gH+dCZzY1u05vnESPM4Mzkry2SMjXCUABWkJ+Pk5o/DkVdOx/v/Oxte/nYeJRa4OlcPhMfp0eGSZWjDvn9hd0buCp9xJ9DW2e34PgbK7QhGeVN74hw/UfgAmKhyeosxE8f+NqGtjl2cgIHWrQR/AQabqUuWcy9kYhmGCggVPDEHuyYIJntPaKFp5b1ULaF/qzFE5AT8n9RzR3BriW1W42IlLAs57CPjRh0DaYKD+EPDMfOCLfwJWa3eHZ4ir4CnOTPQZXHCoVnFl5ozJxW3zRwsHqzgrSTgv7uTIaGovvQ8HaoJ3eJwFT287PEfqnAVPz1yZvVWOtZIztnav4uwx/V/wUJiHFO/cxzMwoJLYgEva7JHUE3p3UQzDMAMMFjwxxiK1j2flrioRBuCezjZtSCYykoLrJZpSrLgp36iOSzdKTgduWA+MvQCwmoCVvwNevhRorRFRy9K9kOVxEhIvvkraDquCZ5ja1+AL+06ih5I2KsWT4imYOUjEBLWkbU9Fs8vn2ZuCp6EHDk9LpwlH6xXH7HsnKVPa73prh7jdHx9+W4FbXtnGZXB9mNKWHK93zJViwTOwYqn9lbRRTSuXtDEMw4QEC54YY+bwLGQkGUQ8893v7cKTnx3EfzYexhtbjor754wOLJ3NWx+PV6jB9vIXgfMfEX0+OPAJ8ORsHN28XNw9PDfZZR4RMdju8HguaStTRYps5PaFvYfHw04i7Ti2Gy3QwGZ3lQJlaFYSkuN06DJb7aKpt0vaeiI49lW12MsA/3DxRAzJShKhEA8sV5uhvbB8RwVufmUr3v/mBFaXKnOOmMjRZnQ4PFLwcHDBwOrhifNX0tZaDXTUAxotkDsmImtjGIYZKLDgiTGobGKhOpDzpa/K8ceP9mDpu7uwtbwx6P4d96S2HceaYJX1GZ6gUrNTrgWu/xTIHQu0VmHK2iX4P/3/cNLg7s5KcaZ3h4dcGenwULKaP+TwUU87iYdV9yQrnnY6gvsvQeEK4wbJsrbeG6ZL0dfhcHj2VCqCZ+ygVCTF6fHQJZPF9Vc2lYuhpp5Yv78Gt/5vmz00od7LLCOm90MLhMPDJW0DUvD4dXiqVXcnazhgCO7ADMMwTKzDgicG+dXCMfj53JG4+tShoqzpvIkFIpntp2cNx8QiZec9GKiHh+bX0PwbKR58kj9eET3TfyRclZv07+HXJ34JNBz2WNJW3dIlYpmdofABej3SUPJxvpA9PJ5CCw6rYiInwYdYC6SP53jv9PGQiHR2uXrSw7NHDSwYW6Csmeb50O8BQdHeH++qFFHgzv1VP/3vFpgsNrsYZMHTdz08yfE65KQqbiULnoGBrIT128PDA0cZhmEiN3iUiX6oJOa2BeEriaAvatrpJ5dox/EmuBameSEuCbYL/oY7tmRhqe1J5DZ9Czx5BnDh34GJ37MPWaRysTajBccbO1z6a6RIoXk9gQxrlUfFqRyM4nydnRzpnuQkICRkH09vBRdUtXS6RBBT+RwJwFCG1Mp5QWMLlKAJ4s7zxuKzfTWibI7ETXFWIn502jCcNCQDS57/WpT7nT4yR6ToPfrpgR45TEzPQwvsDg+XtMVWSZs9oY0FD8MwTLCww8OEBXsfTxAuB7lBb3SejO9Y/gjr4FOArmbgjSXKzB5ju0hbG+ylrK2sJvDAAoL6g7zF+UpXKjdEh2e8UzS1mEXUS4EF1G8j30MoooPW5lzSJqEyqTdvPA03zRkh+rso1OC+D3bju49/IdykKcUZ+NfV05GfFh8Wh4dmQH26twYdyj48E3RogaLMa1tYeA4EzDZNcCVt5JAzDMMwQcGChwkLMqmNHJ5A2X60QZxnFo6EdslHwBm3U6OPMrPnqTlA5U7hNngKLiirC07wUK9Ntj24wHVHUTo8uSE6PKPyU4QQIfeInKhwU64KnqHZSUKQhFrWRnOSWjrNMOg0GJ6T0s31+79zx2Ljnefgge9Owsg85X46//ePThE72pnJyufX0NazlLZ3th3HT17chg/L+c9PoELVxeGRKW3s8AyswaO+Stooxr9aDRbJ40hqhmGYYOE9DiasDg8NtQw0nXm7GpRADgJ0BuCcpcDid4GUAqB2L/D0XHzX/BHt8uFYg2eHp0SdPB8IjuGjXS47k0dq23vUwxOv12GUOouoN8rajtS32R0emWQXisND0dkElQZ6C2dIjNPhiplDsOqXZ+KDW07Huz+bjSxV6GSpceU9LWmTA2OrHHNqGR90mqz2WS0kPGXiIPfwDLQeHh8lbQ1lgLlDSbjMGhaxtTEMwwwUWPAwYWFYdjJS4/Wiv6QiQJNju7rjS70hdoafBdz4OTBqAWDpwvlH/4J/Gf6K+hrXKGTZwzMsN3jB43xknMqzZPhBdogOT28PID3i5PBkqqKjKQSHx17O5tS/4w0qJ5xYlC52sCV2h6eHgudQbas4bzYGMFmesZezEUkGnd3hodvb1bhqZoA7PHLgKMVRa4Pv3WMYhol1WPAwYYFKxiap8dTlrf53ZLvMFpSq4mBacabrnck5wBWvAQsfhFVjwELdZvzf4WuBI1/YU8vkDB4SWj1xeGT/zqC0BBi0PRc8uwOIpqYeli8O1KLD6Jo85w3ZvzQkK9le0tYQguApVR2esWqMdrBIsUWv7TN+3A8Hq5WfXQvPLw0uoS1OJ/6fUVlbgvrLyn08AyiW2pfDYw8s4HI2hmGYUGDBw4S9rC0QwbP7RDOMFqsol5J9Oi6Q5TLrJhz+7rs4ZC1ArrUWeP58YO0fUdnYJpwk6puRw0kDwVOcr+zfIfekJ4wfFLjD89rmo7jima/w99X7A3ruI/XOPTzKe2jsCH5Hd28QDo8npNii2GrqBQoFciUqm5VatjazxiV9jvEfWCDdN+7jGTjI/wI+HZ4qNbAgb1xkFsUwDDPAYMHDhI0pQTg83xxV+3cGp4sdOG/kjp6BC433403LGYDNCqx9EMn/+y4KUKeklvmbXeH8XHaHx9jN4aHn6gkyqa2iqdNvitkhtf9oy5F6v89LQQgyoIDWmKH28ARb0kYx1odUV0zO4AkWisEml6EnZW2y90pSxzN9/OIcWCDh4aMDB2mWxgVS0sYJbQzDMCHBgocJG5PVXpyKdmUH2xc00JKY6l7O5kZqggGGpDTcbroRJ+b+HYhLQXr1JnwUfxe+m7Q9qPXZS9o8Ojw9m1xO65QuEblXvmhQd/JpCKi/GGuZ0EZrd0lKC1JwHKhuFc4MuTQyXjoU5OvXhyh4DtYo/TsS3mH3T5vap+PcT+WpH42JTsz+StpMnUDdQeUyl7QxDMOEBAseJmwUpicgOzkOVmhQWqGUT/kVPEOcAgu8IMvWduWcB/x0HU4kjUWmphW3VN8NLL9D2SEItYdHdT2G9tDhcQ0u8N3HI10NCks45ha37T2hTfkMZEpbsLHUzoEFvhy1gPt42sIkeHiH3S+tXcrBg+R4R7O6vaSNBePADy2o3QfYLEBCBpBaENG1MQzDDBRY8DBhQ0n2Unb6S9UdbE80thvtpWSyDM4Xxc7DR7NH4J7cv+Ip8/nKnZueAp6ZB9TsC7iHx1NoQXgET3pAfTzO7owMEvBGub1/RwlnCHUOz97K5h6Vs3VzeLwIHurJ2XKkAWYv2eSynE/iXF7IBFHSxoJnAAoejZ9ytglKbyPDMAwTNCx4mLBSrLox1Mviz92hoaGyCd/nc6pi5Kg6i+dAnREPmK/E7rOfBZJygKodwFNnKQNLfZSIyb4HShmjpDQSXtQjo7xGz0raXIML/Dg8Tjv50nnxV9Ime4wyQwwtCCaS2hdZ9pQ4z6//xNqDuOSJL/DSV+U+HR5ZVlfNO+yBp7R5EDzO4p2J9jk8Wt+ChwMLGIZhQoYFDxNWCtIS/AoeOXgyEHfHWUQdre8QzoF0PTKmnK/M7Bk+BzC1A+/dArzxY6DTs+AgsaDTauwOhXR3aOc7Kc6xM9nTkjYKB/A1HyUYh8d5Bg/hGDwanMMjSwxDjaSWOHqIPL/+3irl/azbV9PtPuohksEJM0qU3i3eYQ8+pc2lh4cF4wCKpfbydVwlBQ8HFjAMw4QKCx4mrAxK9y945E78qPzA3IbBqrtxrKFd9LyYrTYxh0SIK6ppv+pt4Jy7AY0O2PUW8OQZwLHN3Z6HZphQDLbcUXQEFgQ+y8cXeWkJYkeUTCZvPUwU5tDuNH/Hr8PjFEntLDgopc1f4IGERAWdqBpmdH4KekKWnx6eSvXnvu1oY7f1nWjsECVvlEYlh83W8BwZv3BJ28DGbFMOwsQFUtLGMAzDhAQLHiasFKQrO2Jy1oonjjcqO/FFGYlBOTwkduTA0ZLsZCFgBFotcMZtwI8/BjKGAI1HgOcWAhv+SlNKvQYXHK5V1lHSwxk8nlweb86N7H2RpfiH67y7QTSc9URTh33oKCFjqWmGkbNwCmT+DvUp9dTJyvDTw1PV3NXNQZMcUMvZqJSxQC1pY4cniNCCOA+x1K1dAQtfpn/HUnssaetoBJqPK5dzx0Z2YQzDMAMIFjxMrzg8lc3ed8RONCpiqCjAoaGD1dACKu3ZVt5g32nuRvEpwE/XAxO+C1jNwCf3AC9+D2ipsj8kJ0UGFxjD7vAoz5Xk4nS4I4UC7bDSUXr6iKQgcYcEHt2fFKezr5suy3kdjWr/kT+k+OppYIGLw+Ohh4d+3tUtjvdN4QXOHKxWBM/w3GSeIxNSD0/3lDZyzJpDHALL9K/Box5L2qpLlfO0wUCi/0RLhmEYxjMseJiwkp+aAA1sYkfM01BJq9WGCtW1KAzQ4aGBl3IHb93+WnFe4knwELRT8P1/Axf9E9AnAoc+BZ6cDRz4xG34aJdwV8RzhVHw+NuRl4KHSutkgIC3sjZZzkaBBTJKms7T7UltxuACCwb1LLCAyEz23kOkhEE4RO5WVZxKZP/OiNwUe2JeTauRHYoQStro/0RqgnKdXbIBnNJWvUs554GjDMMwPYIFDxNW4vRapCr7xKhQnRxnqASHdoopPCBfFTHBlLV9e8yR8OYVEgcnLQZ++hmQPxFoqwFevAR466cYrz3i1MOjlrTlhK+kzd5b4WUnVDojJHhkqpu38jf3hDZJZpDR1HvDlNBGyB4oTz08VW5ljFu9ODwj8hwOT5fZKuYRMcGFFhDsksXAHB7p8HBCG8MwTI9gwcOEnQw1aVr2nzgjB21S4IDXVCIfZW2y3t2n4JHkjgGuWw2ccr1y/dv/4bpdi/Gy4Q9IL/8E9W2dYS9p89dMLh0eCh+QjsseLwEH7gltkozEuIAFD6Xa7atq6ZWSNnLrnJF9W/IzoNdt6TR1c3iG56QIhyJRp2xfrfb9MJ5pM3Z3eIgcDi4Y+ILHntDGgQUMwzA9gQUPE3Yy4m1e+1iON3YEFVggcZ+TE5DgIQwJwPl/Bq5bA0y8BFaNDqfpduPn1b/H6rhf4cakNUjRdEVc8GQnx2GcdHgqmz2WdZXXKwJhiJsgy/AzC8cZGoJKLkpagr6bUxQKcm4SaZ1mJzFDVKuCh4IbBmcmisd8c1SJCKd5R/IzoR4eQjqBvMPumzYZWuDu8LDg6cZjjz2GkpISJCQkYObMmdi0aZPXxz799NM444wzkJmZKU7z5s3z+fjensOjlyEsEvqbYE9o45I2hmGYnsCCh4mow0PRxERhhhJuECjFqsNDpMbrhWAIisHTge8/h68v+hRPmi9Asy0Jw7WV+LX1GeCR8dCuuRcJxnr0FJkCV9fW1c0BcXF4kuKE00F1+y2dZrsQ9OjwuAkVKXjk0FRfbCpT3tOMYVmOVLselixKp8E9qU0mtFEf10lDMl36eA45DRxNTVDWn6b+CL2V/zHuJW2O0AL3fjQGePXVV3Hbbbfh7rvvxtatWzFlyhQsXLgQ1dXVHh+/du1a/PCHP8Snn36KjRs3ori4GAsWLMDx42oqWoQw2xz/t1xoqQA6G5W4/ZzREV0TwzDMQIMFDxN2MlWHx1MPz3G1pC3QhDZJsdNO/7DcZHsTf7Ck5g/DH81X4NSuR7HUdA1q4orEToVu4z8wf9ft0L3zE+D4FoRKtpqmRn1KngSJc2gB7eCMzFPK2tzn9pDj4xxa4Mll8TYLx5mvyursgidceAsukD08JGpOGpLhJngc5WySVIPye8IOhW9aOz2XtLHD48ojjzyC66+/HkuWLMH48ePx5JNPIikpCc8995zHx7/00ku46aabMHXqVIwdOxbPPPMMrFYrVq9e3T9iqWU5W/ZIQB94vyPDMAzTnZ6Pl2cYLw6PTGPz5PAUZQRXXkUlUpKepKrJdLB2JOA/loXIm3ETbh58ENYvHoW2/AtlcCmdhswCTr0JGHs+oHU9su6LeL1OODDUX0POhRwU6knwEOMKUkVowZ6KZswfn29/XHVLlyhFo3AHd3EoHR5/sdTkMEmHZ+awbIQL6uM5Wt/RTXDZHZ70BEwqSrcHF9A6DtY4Agsk0uFxjrJmXLFYbegweSlpc5rFE+sYjUZs2bIFd911l/02rVYrytTIvQmE9vZ2mEwmZGV5PzjQ1dUlTpLmZiVwhLajU7DQNtLhgdXi8hzayh2gvzzW3LGwhPDcvYVcYyjvty/hdUeWaFx3NK45ltdtCnI7FjxMrzk8ct6OM8dDLGmjCGuqyKKjoQH373ggOzne/jzEkP9v7zzAoyqzN/5m0nsgPZDQey9SRBH/IAiuC9gVC9YFl11d66ordlHsYlvBuuoqywq4inSQIkVQEKnSW0IC6b3d/3O+O3eYCWmTTJK5k/f3PMMkMzczZy4z8933nnPeEx2mRE1Zh9FYM+8dDPf7DZad84GjG/RLRBtg8BSg341AQO2a/uVAVAmenCJ0jg2tXvBIH88vJ1QfT2XlbLKfKp75ra1pwd5TOWpGi8zuMQaiugIjw5ReoYfIEC5S0iavK8DXop7/4Oncs4In+myGJ4wZnlobFgjM8FTN6dOnUVZWhtjYsycNBPl9z549tXqMhx9+GAkJCUokVcWMGTPw1FNPnXP70qVLVTapLpRp+gmVtT+sQrjd+ZF+R5YhST7Hmd7Yt2gR3I1ly5bBjDDuxsWMcZsx5uYYd36+43BzlwueNWvW4KWXXlJn05KTkzF//nxMmDCh2r+RWmmprd65c6eqk/7HP/6ByZMnO/vUxGQZHilxkrP79r0jhuCxz9jUBjnojw8PVH9fH8EjGRMRGzJ4VGhr54CWFdQWZePuhuWSp4GfZgNbPgQyjwBLHgFWz9CtrgfdBbRoU2Mfz++puZUeiNrbUgtVObV9sUm3z+4Se65QOWtLXX1J26aDejnbgDYtnHLEq6s1tWFSERumi7TerSNUhunnI5lnS9ocBI9+zQP2mmfwyPvWv0KPBwWP63jhhRfw5ZdfqrVKDA+qQjJIspbZZ3iM3p+wsLA6ZabKN6xWP4++ZJRDb6LPnJfUdadhE9Cxyzi4C3JWVQ5QLrnkEvj6Wj/EJoBxNy5mjNuMMTfnuLOtGfYGEzx5eXmqGfS2227DFVdcUeP2hw4dwmWXXYYpU6aommmpj77jjjsQHx+vGkqJ5yGlSqJxSss11VAdE6YfQIirlzToOzN01J7xfROwcNtJnN+xfuVZIkgMwdOmZSXiKSweGDkduPABZWWNje8Cp/cBG94CNr4DdLscGDoNSBxU6eMbB6IVm8lF/Bl9Lw4ZHvmcnMlDfrFkY3yw8eAZLNh2Uo0Tumdkp3MeP7yWJW2bD+vlbEPau66czTBcqNjDI/bXxuuVHh5BjAtE8EgcxpDXDlaHNsFaXcgD9loInmA/73P61oz3mQz4rXhiobkRFRUFb29vnDp1yuF2+T0uLq7av3355ZeV4Fm+fDl69+5d7bb+/v7qUhFZrOuyYMuAZoOgAL+zj1Fepn/nyCKd0EueAO5GXV9zU8O4Gxczxm3GmJtj3L5O/o3Tp33Hjh2LZ599FhMnTqzV9tI42q5dO7zyyivo1q0bpk2bhquuugqvvfaas09NTIIMDDcOxk7aWVMb/TuSoZADe2d56NKuWP/3/0NMqHPlcFU5qUkchnioFL8gYOBtwN2bgEnzgPYjAK0c2LUQ+OASYPZI4Lf/AmWltTrzLoJPejLs+3AkFrmIA+2+U7koKSvH9IW/qfsmDU5Cr9Z6L0xlgqO6DI+YHtg7tLmSloZpgV2GRx10a3omItK6fw3jgiW/pSgTBylxSwg/K3RZ0lYzuVZL6orlbIZoFg0k76naWJR7Mn5+fhgwYICD4YBhQDB06NAq/27mzJl45plnsHjxYgwcOBCNjXzeDXwtdstx+kGgrAjwDQIi2jZ6XIQQ4mk0uEubNIxWrImWzE5tG0mJOYkP10VJsp3dsuHQVpfsjiuJsjqp1XrgqByIdLoEuHkhMPVHvZ/H2w84sQWYdxvwRh9g/RtAQWa1gsfo3xFbbTE3MOhmLWsT84JPfjyshI8czD4wukul4dhMC/JLKp3fIxxIy1NZLCmD6l2JaKoPhhGDfQ+P4dAm/UsieoT+bXRr6hxrlqJdVIhDFsIwLZDHsT/wI5VkeCoRPFI2aIhfGhdAlZrJbJ1PPvkEu3fvxtSpU1VFgri2CTfffLODqcGLL76Ixx9/XLm4yeyelJQUdcnN1fvNGgM5EWAgFvU2Tu3Ur6O76t8/hBBC6kWDmxbIAlJZI6nU3hUUFCAwMLBRnHDsr82CGeM2Yo211isdS8+z3Xb0jH4gkRAe0KSvqaVVMCS1CDxnH9cYV8vOwLjXgeGPwvLzR7Bs/Qhe2ceBZdOhrX4R5X1uQGLwBJsIsH+81Kx8m2Cxv71zTDDW/n4aK3efwo8H9L6bBy7phGBfr0rjCfHVD4ykZDAzTxcaFbfbsD9NXfdNDIdFK0dJiesERaiffgCWnltke96T1iGpMaF+ttvC/S1IahmIo+m60G0fGeSwn4N9JBvohTJNw6nMPNX701R8vvkY1u8/g5ev6lll9rEpPo9Zefr3oBhPVPa8UcF+SkgnZ+SjQ2SgWzjhNBXXXnst0tLSMH36dLXuiN20ZG6M9efo0aPKuc3g3XffVT00UnFgj8zxefLJJxsl5tJy/XMpmTrjRIEidbd+zYGjhBDiEtzSpa0hnHCao4NFU1KUIbX0FmzYthuxmfrZynVH5GDDgqKMFCxqQtehsBwgNtAbCcXHsWjRsXrs616wdHoBrTM2oEPqEoQVHof3ltkYhzl437c/Fpwci0XfpehHMwB2pMu1Nywl+Q6vvyhNv33Zbn1AYtsQDYEp27Fo0fYqn9nXyxslmhe+XboKkQHnxr3gd31fR5Sccfm+/j1Lj/dYaobtsdel6Ldp+ZkOzxdjseCoNZFclnkSixYdt90nx3chPuXIKvHCgsUrkXjWz6BRkSTZzC3eyC/1wqtfLkP/qMqzZk3xefzJ+t4oyDm7rx0o0v+fV6zfjOx9mls44TQlUjItl8oQQwJ7Dh8+jKbGyPD4WLwce7RSrRmeGAoeQggxheCRhtHKGknF0aay7E5DOOE0VweLpox5cK/OWJ28H4GR8Rg3ro+6b+lXvwInUzCsb1eMG9a0del/dum+ngBoL6D08BpYNr0Ly4HlGO29FaO1rdCSe6Fs8FRo3Scgb1sqsHcX2iVEY9y4/ra/bp+Sg8/2b7CJgNdvGlqjjfTzO39Qc296DRiCkzs3OsQtZW4zdq6Ro2HcMOo8nN/BtaYF+07l4K1dG1Bi8cO4cRer2/Yu3w8cOohenZIwbtzZg7SMTUex5VvdFnj00D4Y1zveYX+3igpFVnIuOvc5Dxd3iUZTIIYK+RvXq5+1yHYYN66r23weZf9h/x60SYjDuHF9z7l/Zf4O7NuejIQOXTHugnZu4YRDao9RyulX1dBRCh5CCDGH4JGG0YpnJmXxra6R1NVOOK76+6bCjHG3aqFn4lKyi2yxJ1v7PBIjQ9z29dRrX3cepS7ph3fg+zlP4ArvtQg8tQM+39wNrHwa3VqMxkhLNFoFjnB4ji7xEap+X8723jikDfq2qVmgSO+GCJ7cEu2cuI+l56v9LmeNB7WPhq9v7Qen1obocP3/NqugBBZvH1WKc9ranxQfHuTw2ga2i7L93Dku/Jx9Gy0GFMm5yCgobbL3xI6TZ3s2th/PqjGOxvw8Flj9MEIDK3/OWKsJRHpezfuvsZxwSB0yPPb9OyUFummBQMFDCCFNI3ikoXP//v0OttPbtm1T06mTkpJUdubEiRP49NNP1f1iR/3WW2/hoYceUlbWK1euxNy5c/Hdd9+55hUQ9zYtsHNpM2bwtGpi04KGJjypJx4vux0vlV6DdSMPI2T7R0BuCvrlfooPpLVp7yvAW12ApCHq4pc0BLcNa4tfj2fj/ku61O45An1toqOiGfEmqzubmBUE+rlW7AhGo7y4smUXlCgTAxFfQqz1/92ga1wo2kcFo7CkDB1jzq1ZE5ODpnZq++WobjYh7DyZrWINcLFIrK9pQWUubfb7r6IFOjFXhsdhuHCaZEQ1ICgSCIlpuuAIIaQ5C54tW7bg4ov1MhbBKD275ZZb8PHHH6thpNIcaiCW1CJu/va3v+GNN95A69atMWfOHM7gaSaCRxr3ZUaLHBynWg9qWzk5dNRsGNbMaTnA4e5T0fPi+4Dd32Djiq8Rlf4LOlpOAqf36pefP1F/80hwjC6AtusiCHG9Ae+qz6zbW1PrXmjnDhwd7OL5OwZycCZOc+K+Jg5ruuA5O3TUHhl4unDaMDl8q1RERFvNLZpU8BzLsP0sRhC/ncjCwLautfKuK7nVuLQ5OAJS8JiSUmuGx0Hw2JezVZi9RAghpJEEz4gRI6q0whVE9FT2N7/88ovz0RHTIrNlpKRKDiDlYKykVFPN4WKTbD9N3JNfvxzEqwPRVuFAr6vwzy1JWJWShtcvT8SEyOPA0Q3AsU3AiZ+BvFQlitRFkPkbrQYASUOBpMFA60FAQNi51tQFpecIHmPgqKvn79gjIkcEjzELyBCzxtBRe0IDqhZuRobC+PvGpqC4DLuTc9TPPVuF4bcT2fj5aIbbCJ6aMjzGTCnOMjJ3hke+K22ksn+HEEKahUsb8Ywsh5ztlzK2k5mFtoniUs5WcWK8JyJn3ncnOx6Ipufr9r7BLWKBrr2BruP0O0oKgZO/6ALo6EZdBBVmAofX6hfBywLE9LCVwSV6R1c6fDQlqxBHzuQr84OB1jk4DYEInqPp+UjPK0FRaZltxlCsk0NhjZlITXXAvuNElhrcKULtsl4JuuA5crbEranJK7ZmeKooTaxq5hMxByVWW2qHDI8heGhJTQghLoOChzRoWZsInuSsAhRa58A09dDRxqKy3op060wVGSrqgG8A0GaofhHkIEjK3UT8KAG0Ecg4DJzaoV9+mq1c5ib4RyLlQB/4hrUGTiUBCb2x6ZBeztYjIbzazIqrZhll5BUj1dq/4+djsWWeaktTl2T9clQvZ+uX2AL9kyLUz5LhkSy2Owjz3KKyWpW0ZeSXqJMK8n9AzGda4DB01JjBIyc4CCGEuAQKHtJgxIu4OZKB5MxC5BeXNQvDgurOvGfklVQueCoiwxFjuumXgfqUeOSknBVARzegPGUHWuEMWmWvBMQ1eM6ngH8Yuvl2xV+8kxAdOQIo7gf4BTfI6zN6iKSHJzXH6N/xd1okGPtJRFNTiIxtx/RsTr+kCPRuHaEyk1JedzKr0C3eqzWVtEUE+tpKR8/kFSHe6tpGzIH0NzpkePLTgZxk/eeYyu3RCSGEOA8FD2kwEqzGBSezCpBvPVOd0EwFj5R9GQ3oLa1iwSlC44AeE/QLgBXbDuCjufNwecQRjPTejuiiQ/Aqykbnos2433czsG8e8MK9uvmB0QfU5gIgONJlJW1Ghsfm0OZkOZsQZX2cgpIy5BWXVXlg39AObX0TI5SjXbf4UGtZW4ZbCZ6qMjwWi5fq40nJLlTvNQoek9tSG+VsEUmAf2gTRkYIIZ4F6x9Igzu1SV+JzZLawx3aqupNMbI7kkEIC6z/QX1YWAR+LO+J2ZarsaHjQyi9/wCOX7ME00tuwXflQ1EeGg+UlwInfwY2vg3MvRl4tRuw5DH9LHI9MbJUGfnFVTq01QY5kDf6UxqqD2XH8Sybc509UmopQkH+T3q1Dle39U9qYStrM4NLm8A+Hg+ypWY5GyGENAgUPKTBiLOebZbyoJNWwZMQ4fxBsRmp2Jsi5UZGKZgryrYirFki6d1QWHywLCMWn5aNweeJT8Jy327g3h3AFXOAgbcD0V2BsiJgw1vAG32ANS8DxXn1L2nLK7FleGIqcWirDQ15wF5eruHmDzfhutkbsTtZav/Oze7IrKAgPx8HwWM/m8edS9rs9x9n8XhAD8+pnfq1lLMSQghxGRQ8pMEwxI2IHSPD0zoiCM2BGOMgtEKGx1WW3C2Czg4elRlHwpp9aep6eOdofX6HlMX0vhr4w6vA3RuBSfOA2F5AUTaw8hngzX7AT3OAMqtocoKWwb4uyfAIMdZSOKMXyJVIfCIKxRL93dUHKjcssJoV2AuenSez1ADSpibPZlpQ9SBUdxjeSuqZ4ZG+PQeHNmZ4CCHElVDwkAbD6CeQA7Gi0nJ1DB5nLXPzdKJD9NeZXViqDpyluV9oYRUK9SUsUH8cETuFZdIjVI6NB/VStYtE8FREdn6nS4A/rdGzPhFtgNxTwHf3A28PAn77r+4O52yGSfXw6EIlro6CpyEzPFKyZvDtrydx+PTZrJaRxRGHNoPEloFKlMqZdxE9TYm4rhVbD4iry/BEucHwVlI3xGzCluERVW4raaMlNSGEuBIKHtJgyIGjn918Ccl6NBfbXOnTMV67lBqlW8uNIoPrVvZVkQBfbwT66mf980uBrUcyVOO/7GMp0aoSOZMsWZ9pW4CxLwHB0UD6QWDebcDsi4EDK+vcw+OOJW2GZbYgx5b/XHPAJiZkBo/Q1y7DI+WG/dykrM0oZ6uxh8fI8LCkzbyDR+W7Iuu4nn21+ACRHZs6NEII8Siax9EnaRLEQco+o+MOrleNhRw42xsXGENHXZXhsS9ryysF1vx+Wv18Yafo2vUI+fgBg+8C/roNGPEo4BcCJG8D/jUR+OSPwImfa3hu/bVlFpQoU4r6lLQ1pOAxxJhhoDFv63FlVrAnJVtlxcIDfdEu0tG6u3+bs/N43MGwQE4SOAymrEC0tSSQGR6T9/AY5WxRnfXPJyGEEJdBwUMaFHvB01wsqSs7kLcNHa2LJXUVhFsfK7/UC+v26y5kwztHOfcg/iHAiIeBe7YDg6cC3n7AoR/0bM/cW4DT+yv9M2PAqFThiJ20KwSPzL9xNYahwogu0RjSvqU6wJy95pBt/o7YUYswt8fm1HbEMcMj2axf072w+XA6jp7JV1mihiSvuGbDAoEubR6S4TEED8vZCCHE5XAOD2mUWTzNyZL6XPes4toPHa1Dhic5H9h7Kle16UiGp04ERwFjXwCGTAVWzwC2fwnsWgDs/h/Q/2bgooeBsHjb5pJxCAvwUT1K6s/9vOs8Q6dBMzxWIwQxRhjXKx4bD27GF5uPYFC7yHMMCwx6tw5XVtXS/yPZIOlFW7IzBY98/SvS87zxwd4ttm1lBs7Efgl47LLuDTiDp2rDAoGCx/wZHj/J8JwyBA8d2gghxNUww0MalHi7rE5zKmk7N8NjmBa4TvAYWZafT+sf496twusvqFq0ASa+B0xdD3S+FNDKgK0f6Y5uy58ECs5mPexfS2w9zCgasgcl1c5B7oKOUUrMFJaU2xztjH4de8Si2uiDku3un7sdf/rXVmXB3dJfQ5uWQbZeNOnPmr32EAqsWa7aoGkaftx/GplWI4uqyDUc2qyW2TW9zyTTlm/NChFzUGo/h4cObYQQ0mBQ8JDGy/A0N8FjO5AvtAkeV5kW2DulHcvzOmtH7SrkoOuGr4BbFwOJg4HSAmDda/oMn/VvACUFtj4etbm1j6Q+Ft5ncotQZnhsu9ilLTbMX/U23T3CsRm8b+tzMzz2ZW0P/3cH/vvzcZU9u+vCtnisbxmW/+0C7H3mUmz9xyib6Dxk5/5WE4t2pOCGOZvw/CKrI1c9ZvAY2TXDwOJ0zrkiavo3uzDvkAXHMvJrHSNp5AyPVxlwep9+I0vaCCHE5VDwkEaxpm6OPTxR9hkeF9tSCxFWa2oDlwoegzZDgduWANf9G4juBhRmAsumA7MGYHz5CnjD6N+pu5CLDPGHtNGI1jEGtLq6h8foLxrdPRadYkLUz+2jgxFuFSwVMYwLDKvquX8aigdHd4ZhMijiSeLuEK0/1oG03FrHtGLPKXW9OzmnVqYF1Tm0GbGcHXTrOMtIBOT8bSexNsWCUuvBNXEfSq1W8LElJ4CyYt08JDyxqcMihBCPg4KHNChxzbmHJ+RsM77Mq3F9D8/Zx5IsgDTgNwiS3ug6Ti9zG/8OENYayD6BW8+8gsV+f8cYy0+ItR5w1wXpl2lpzXwZjm+uKheSkjN7wSMGBfeP7qJe0pgecVX+7chusRjcriVuGdoG398zHOe1bVnpdu2jdIe3g2m1z/Bsss5LSq7htdY2wyPYOwLac+RMnirh87VoSGrZPIb+moliqwiNKzp4tn/HGEJKCCHEZdC0gDQochZd5vFIc3dYgOuyG2bAOOsuB8PGgEF7kVJf7LMT53doWa11sUuweAP9JgE9rwS2fID8FS+iU+kJ/NPvNaTuWwH0mAG0vaBOD90jIQw/7EvDyj2p6F1FmZmziFmEuMiJoJL3oMGlPeOw+dFRNtOHypD36ld/Glrjc3SIcS7Dcyw9HycyC9TPks0Sp7eqZlPV1rSgOuOCPSl6FikhSN8PxD17eGIL7QQPIYQQl8NTSaRBkQbw1Q+OwMJpw9DcMA5CswpKbL0WMjC0IUraLuzopB11ffANAIb+GZ8PXog3SycgX/NHTNavwMeXAZ9dBaTscPohJ/RLUNcLt51UTf2uwDYQNdT/HOtp+b9RVsD1xJbhOV07wbPpkJ7dEeRlplpd5Ko1LahFhqcqwbM7OVtdJwSxnM2de3hi8vWBuIihYQEhhDQEFDykwQkN8HXpgb5ZkKyWPS2tZUeuwt4l7cJOus1yYxISHolXS6/BRUWvIbXrjfqE+P3LgPcuBP57J5B+qNaPNbp7nGq8l+b/7cezXCt46jgfqDYYGR7J4tVGqG08qM9LqhhjfUvaokMCKnW6M/qEKHjcew5PZL41wxNLwwJCCGkIWNJGSAMhZ+aD/LyRb7UsduXQUUGa72UWTqxfcZM44BnleWmIQNHol4BL7gNWPQf89l9gx1xg53xg4K3A8AeBkJga99XoHrEqw7PglxMu6UcyxER9+otqQvpifCxe6v9YHOHsTToqY9MhXfD4enups/vV9fGcLWmre4ZnTwozPO6MGEkEohBhhSf0G+jQRojLKS8vR3Fx9WMAhJKSEvj4+KCwsBBlZbUfNdDUeGrcvr6+8PZ23clyCh5CGhA5ED1yJt/lhgWGLfWaB4Zj2dKlaArsX4864PbtAFz1ITDsHmD5U8CBFcDm94FfPgfOnwYMnQYEhFX5eBP6tVKC53/bT+Kxy7rVuyepokNbQyAxiug5eDoPB1LzqhU8xzPycSy9QPXSyIBY6VeqzqShti5twlmXtrOLenZhCY5n6P1CCXrlHXEzisvK0dnrOLygAcEx+gBgQojLEKFz6NAhJXpqQrL0cXFxOHbsmHK/NAueHHdERITaxhWvi4KHkAZ2ajMEjyuHjhrIwbBfE1ULxlsd+OLCAhxLFuP7ADd9DRxaow8rPbEV+OFFYP2bQGAL1QPk4+2P4XlF8D79DuAXBPgE4CJvf8wKzEBWkTdS5n6LxOiW6nbVM+QTCPiIqLJeV/u7bB+AU1kF5zgFNgTto0OU4JE+ngs6RdXoztarVbjq/VlZgytdnnWIaIgTpgWn7TI8e62GBfL/FORTe9ts0ri21J0tx/VfWM5GiMsPqJOTk1WWIDExEZYaHBBFFOXm5iIkJKTGbd0JT4xb0zTk5+cjNTVV/R4fH1/v56PgIaQBMQ5EG6KkralJbBmEt27oV3VWo91w4I4VwO5vgBXPAGd+B3J0ESLnatRoT6N3wdpQeLnxrbTXeqkHL8KCp/x94f1jIPBzEOAfosfU4wogaajL7H87RAdj+W7gQGpurcrZhrSPtNlIG4NRqzUt8HPOlloWCjkbtsdqWNAlVvqMKHjcESlr7Op1TP+F5WyEuJTS0lJ10JyQkICgoKBal74FBASYTjh4YtyBgfqxhYiemJiYepe3UfAQ0liCx8WmBe7AH3rr7mpVImno7uOBrn8AzhwASvKB0kKUFuZhy8a1GNi3F3y0EnUbSgpx4nQG5m74HcHepbh1UBx8tWL9Puv9xs/5+Xk4lZ4JS2khArxKEBOowau0CCjVBZVgQTmCvIqAErlkApLwkGn2P80BQuKAHhN08dP6vHqJH2P4qGR5qmOjNcMzuH1LW39OtRkep+bw+NtKpLILSpVl+S6rYUG3uFCgJKXWr4c0rmlBF6+j+i8UPIS4FKMvxM/P89be5kKQVahKvw8FDyEmcWrztAyP0zN8ojvbftVKSnBqdy60buOkM9F2e4KmYeHu1Th8Jh/RrfpgYr/WDg9TVq7hn2sO4NWl+2yzjYSV0y5SpWXK61km1pcUYNTMJSgszMe/bu6DduEWICcF2P0/YM//gNwUYNN7+kUGqRrip1V/XaQ5OWtKqC7DczKzAEfT81X/zsA2LbDvVE6NGR5nTAukpFAMLLILS5GWW6gEj2FY0EUEjzWJQNzPtKALS9oIaVDM1NdCGu7/zjy5L0LMnuFpgB4eT/xyE/MCYf4vJx3uO5iWi+tnb8TMxXuV2Lm0Rxw6Wm2h952yig35cvTxR6FPKPYXhOC4FoMWbXoCCX2BLpcCE94GHtgPXP8V0Ps6wC8UyD4ObHgLmPN/wBu9gWXTgZPbdPHkRIbnZFYh8q19N1WVs/VsFa5s2g0jBXGSK7cTbnU1LbB/r6XmFKnHNHp49JI24o4ElmQg2isLmhR5Rndt6nAIIcRjoeAhpIFNCwwoeGrHhL664Fn3e5rqSdlyOB13fboFI1/9AZsPpasBri9d1Rvv3tgfvVuHq22NjImBYc/s52NBuN2AVoWPny5+rvgn8OB+4NrPgZ5XAb7BQOZRYP0bwPsXAbP6671HKb9VK37EjKJFkP4cMkeoMjYe0MvZhrRrqa5jQgOUNpMejvT8c+1SpQ/HmZK2itbUkk0Sq2x/HwvaRtZcu06ahtbF+qyqgpBEwI9WeoQQ0lCwpI2QRsrwNIRLmyfSNipYzeHZdiwTf5i11mYvLYzsGoPpl3dHm0j94LBLbGilgseYwSMOctWmxMUBrtsf9EtxPvD7UmDn18C+pUD6QWDty/olqjMs3cYjpFAXLBWRcrqtRzJwIC0PPRJ0EVaVYYEhxCKD/XE6t0j18VQcUltYUg4j8RNcC5c2ITrUOnw0p8hWztY5NhQ+9bT3Jg1H69LD6jo/ojMoSwkhrqZt27a499571aW5Q8FDSCMJnkgKnlozoW+CEjwidvy8LbiifyvccWE7dIzRBY6BHNBXLniMGTxODB0Ve2zVyzMBKMoF9i3Wh6f+vkyZHXivfQkjJfvy/qdAzyuBnlcAkR1sTm0ieKTsriIiaKQnyeIFDGyrvOlsdtGG4JFSt8rK2YTgWri02WcTT+cWI6dQ//uu0r9D3Ja2ZUfUdWHE2f42QkjzZsSIEejbty9ef/31ej/WTz/9hOBgZo8FCh5CGhDp1egWH1Z5aRWpkmvPS8LeU7lKMN40pI2DcLSns/WA/mBaHopLy9V+ts/wxNR16KhYWPe6Sr8UZgN7v0f5jnlqmKolbTew6ln9EtdLmR30CRmAuWJckJZXY/+O/Xtjx4ksJFdiXGCUswX5ecMiSsnJkracwhL1c9f4qge9kqanXZme4SmKZP8OIaR2SMmzOND5+NRiKHV0dKPEZAZY60BIAyKuXN/95QLMn3o+nWKcINDPGzOu6IX7LulcpdgREsIDVI+LmBgcPnNWbJzK0UVErLXMq14EhAF9rkXZtV9gcc+3UPqHWUDHUYDFB0jZAax4CpM2/hEL/f6Bvkc/BTIdLdE2HnQsZ6s4uPVUJdbUzhoWOMziyZWSNqsldTwzPG5LeTnaavp7pYSCh5AGRw2zLC6t9lJQXFbjNnW5yHPXhsmTJ+OHH37AG2+8oY4Z5PLxxx+r6++//x4DBgyAv78/1q1bhwMHDmD8+PFqKGfr1q0xePBgLF++/JySNvtMkZeXF+bMmYOJEycqy+dOnTrhm2++qVVsIrJuv/12tGvXTs3I6dKli4qzIh9++CF69Oih4pTYpk2bZrsvMzMTf/rTnxAbG6uef+jQofj222/RGDDDQ0gDU9sz9MR55Mu7U2wIfjmaqcrajBI3Q0Q4VdJWC0p8gqH1GQcMvBnIT9eHqu6cD+3QGvSxHESfgoPA6x/qs316XAGt+3j8eEAXPIOthgUGcVbBk1yJ4MmwGhmI1XRtMYTh4dN5yrRA6BrHDI/bknUUwShEkeaD8hbtmjoaQjyegpIydJ++pEmee9fTYxBUi/JkERD79u1Dz5498fTTT6vbdu7cqa7//ve/4+WXX0b79u3RokULHDt2DOPGjcMzzzyj5tTMnz8fl19+Ofbu3YukpKQqn+Opp57CzJkz8dJLL2HWrFmYNGkSjhw5gpYtK+9RtR8UKsLqP//5DyIjI/Hjjz/irrvuUqLmmmuuUdu8++67uO+++/DCCy9g7NixyMrKwvr1621/L7fl5OTgs88+U8Jpy5Yt9Z6vU1soeAghpqZzTKgueCSr0btiD48LMjxVEdQSGDBZXUqzT+GZmS9gnGUDBlv2wOv4T8Dxn+C15BG8VN4FS/zOx+DoPg5/LoYKeqznCh7DUtqw3XZG8BhiR8SeOAPKQkjckFO71NUBrRV8fdnfRwgBwsPD1aBUyX7ExcWp2/bs2aOuRQBdcskltm1FoPTp00cJiezsbHX/ggULVMbGPqtSWRbp+uuvVz8///zzePPNN7F582Zceuml1cbm6+urxJKBCJYNGzZg7ty5NsHz7LPP4v7778c999xj2+68885T15J9kufZvXs3OnfurOKOiopCWFiY+wqet99+WynDlJQUtbNFIQ4aNKjK7SWdJqrv6NGj6sVdddVVmDFjBgICGvBghBDSLDD6eGyzeOxL2hpS8NjhGxaLdS3G49O0UfjyhrYYUrAO+O1r4NhGDLLsxSDsBd7+BOjwf8AN/5G0n12Gp+Ccx9uVrLusdY8/1/GtKiqW/knvWHPDmbVJzppOnz4dW7duVWc3X3vttcZ1MkrVBc8eLRH96aRHSIMT6OutMi1VIQfgOdk5CA0LhcVicflz15eBAwc6/J6bm4snn3wS3333HU6ePKlKzgoKCtSxdnX07m09Myhl08HBSnCkpqbW+jtWStbkOeS5iouLlcGCII8hcYwcKfY+57Jt2zaVIRKx0xQ4/T/61VdfqXTVE088gZ9//lktKmPGjKlyZ33xxRcqDSfbi6r74IMP1GM8+uijroifENLM6WwdrGnv1JZaF5e2etI+So9jb24wMPhP2DFmLoYUzsKzpTehKK4/oJUD3n5K7AiG4LG33TbYnex8D47YXNtXTza3cjZn16b8/HxVGiKlF8aZ1Eal3XC8XTYBS8oGwodlr4Q0Sgm0lJVVd5H+0Zq2qcvFFT28Fd3WHnjgAVXGJlmVRYsWqe+9Xr16KRFSU6bGHolNxF5NfPnll+o5pY9n6dKlSsDceuuttueTvp7qqOl+txM8r776Ku688071Irt374733ntPpd5E8VWG1PgNGzYMN9xwg2qeGj16tEqlSVqLEELqizGLR0wLCkvKVMO/0fRfZ5e2OtAhRl+MDlitqd/74QBSEIn0XnfAf8oq4J5fgZFPnFPSJrEarmqCuM3tTzUET5hTBhktg88KvOZmWODs2iRlFpINuu6661RzbWNT3uo8vFRyDZaUD4IvMzyEECtS0ibZmpqQ3hgpTxMDAjEJkBM3hw/rzo8Nwfr163H++efj7rvvRr9+/dCxY0dlnGAQGhqqjvNXrFhRZWbp+PHjqkepKXCqpE1UnKT/H3nkEdttkvYbNWqUquOrDNk50pwkAkdKCw4ePKiU6E033VTl8xQVFamLgdQmClKLXpd6dONvzFbLbsa4zRizwLjNG3dEgFh++yCroBR7kzNtpQMysNPforls39QUc5sW+tkrESu/p2Ri0W/J6vfbhyXpfxOSYDyQuvKzAKEBPmpmzvEzubZ+nT3JOSgp09R9sSE+TsUvTm0y20foGBXo8J1Z1/1ghvdWXdampqbE7oyqrzczPIQQHRENmzZtUuIlJCSkyuyLOKx9/fXXuOyyy5CXl6eMCGqTqakr8nyffvoplixZovp3/vWvf6k5P/KzgZTYTZkyBTExMTaDAhFKf/nLX3DRRRdh+PDhuPLKK9UJKsmwS1ZKMldivuBWguf06dNKdYqdnD3yu9FUVRHJ7MjfXXDBBcqWr7S0VO2M6krapL/HvjHKQFJocsaurixbtgxmxIxxmzFmgXGbM+4oH29kwQvzlq5HuOr/9kawV6k6udJYMetJGR/sOnYGT3yxFppmQfeIcuzfuhb7q3isYC9v5MAL3yxfi64Rum3p5jQ5+PVGjG+JsiF1igLJFFjg7aVh709rsd9S/30tpV/uTl3WprrgypNx+XbDZVFeZgphKfAkS+PCuOsXgxx3igiojRAwrKONv2kqpDTXyFRLn4y0gggVX4c4tt1xxx3q+FoMDB5++GElMCrGX/H38kr2R232kWTQRaBce+21qgxOsuNTp07F4sWLbX8ryQxZM8RtTsrfpG9fBI5xvzi8Pfjgg6rSS0SaiCUpK67queV2iV/+Lyu6uTn73vLSamsODqhmpFatWqkyNfHONnjooYeUb7go0oqsXr1a7RSpMRSP8P379yv3Btlxjz/+eK0XlcTERLWo1cXNQXaKLPbiblGxdtGdMWPcZoxZYNzmjnv6N7vw75+O408XtlM21Q/M24Eh7VrgX7fp7jCNEbNYSQ+asdp2xl6yNF/cfh7Oa9uiyse89ZOtWLf/DF6Y2ANX9m+lbpvx/V58+OMR3DQkCdMvc24+y0P/3YH525LRLS4U3/x5qEv2tXz/yqIl9qKN5abjLHVZmyqeURXDgppMC+TsZWUn46RX1dmTcXklwKNb9HOOrw0pdei/IoTUHxnMKWVecvwoZWLEfEj2Xuy3xYhGEib2iLCSpEpt1yanMjyy6InCOnXqlMPt8ntVTZ8iakTxiQoVpKFKVJ14dz/22GOVOmFIPXVlNdWyWNfn4Ki+f99UmDFuM8YsMG5zxt1VuZkdx4HTeWgZon93xEcENcg+qSrmmHBftAjyRUZ+iRI7/ZMiMLRjdLXNqvHhehlcWm6J7TH3WN3merWKcDr+uAj9oLtbQtg5f1vXfW2G91Vd1qa6ICVzcva14sk46U11Vgym5RQBW36AFzSMGW2eExY8ydK4MO66U1hYqA6WpSysNq7Acv5fMiTSi2KmQeGeHHdhYaEyO5BSuIr/h0aGvbY4JXhEIcuUV2lImjBhgi3dJL9X5fktCqyiqDHSUk4klwghpEqMgaN7T+UgqaVuHhDTiA5tBh2iQ7DlSIb6ecpFHWpcfOKtTm0p1lk88p2422pJXRdb6WsGJuJ4RgHuuKA9mhN1WZvqgktPxln0s5XSvmPGExZmjFlg3M0nbilzle9gOQatjc20UVZl/I1ZcFXcU6ZMUT33lXHjjTcqI5jGjltul/srex85+75yeg6PnN265ZZblB+4mBDIjB3J2Ei9oXDzzTer0gLpwxFk6qs0J4mjg1HSJlkfub2xpqsSQpqHNfWx9ALl1ibEhjb+nK/20cFK8IgBwahujv0klRFrCJ6sQptFtWSIxHFNSvOcpV1UMGZd3w/NEWfXJimV2LVrl+3nEydOKJtVORss7kMNTUmZvtjTr4AQ4g48/fTTqu+mMty1nLlBBY80K6WlpamBbVJTJwOHpGHJaBaVYUT2Su0f//iHUmdyLQtKdHS0EjvPPfeca18JIaTZEhnib3UoK8amg2cadeioPVcNSMQvRzMx/fLusNSiKaNihmdXcpa67hAdjAAXDKprTji7Nknfj5yIs28Alos4CUnvaUMjZY8CHakJIe5ATEyMungqTgseQUoEqioTqLhQSNOYDIKTCyGENBSdYkJxOvcM8orLGn3oqMGgdi2x7L6Lar29IcqMDM/ZgaPmP5vWFDizNolRQVOWVTPDQwghjQfPLRFCPIIucY6DNpsiw+MshmnBmbxiFJWWYVc9+neIuaDgIYSQxoOChxDiEVTseWkK0wJnEVc3Px/9azg1uwi7T+qCpzsFj8djlLT5UPAQQkiDQ8FDCPEIulid2gwh4e/j/j0w0t8YZ81EHTydh0NWwwVmeJpRhoerMCGENDj8qiWEeASd7ASPGcrZDAzB88PeNEhLSVSIP6JD3T87RepHqWFawAwPIYQ0OBQ8hBCPIDzQ1yYeYswkeKxObav2pqrr7gnM7jQH2MNDCGkIxJBFbPmJIxQ8hBCP6+OJNVGGxBA8h04b5WyO5gvEMymm4CGEkEaDgocQ4jH0S4xQ1x1inB/a2VQYWSkDGhY0D1jSRgghjQcFDyHEY5gyogPev2kAJp/fFmbL8BhQ8DQ304KmmwVESLNCmiSL86q/lOTXvE1dLrWc+fX+++8jISEB5eX694PB+PHjcdttt+HAgQPqZxmoHBISgvPOOw/Lly+v8y559dVX0atXLwQHByMxMRF33303cnNzHbZZv349RowYgaCgILRo0QJjxoxBRkaGuk/inDlzJjp27Ah/f38kJSXhueeeg8cMHiWEEHckyM8Ho3vEwUzYCx6xqG4XFdyk8ZDGFTy0pSakkRAx83xCtRkAvUagAXj0JOBX83f71Vdfjb/85S9YtWoVRo4cqW5LT0/H4sWLsWjRIiVGxo0bp0SFCIxPP/1UCaDNmzejR48eTodlsVjw5ptvol27djh48KASPA899BDeeecddf+2bdtUHCK23njjDfj4+KjYysr0Ad+PPPIIZs+ejddeew0XXHABkpOTsWfPHrgjFDyEEOImJW1ire1Dn+JmNYeHJW2EEAPJoIwdOxZffPGFTfDMmzcPUVFRuPjii5VA6dOnj237Z555BvPnz8f3339fJ8Fz7733OpgdPPvss5gyZYpN8Ej2ZuDAgbbfBeN5cnJylAh66623cMstt6jbOnTooISPO0LBQwghTYhYUFu8gHKN5WzNiVJryQr1LSGNhG+QnmmpAinPys7JQVhoqBIWLn/uWjJp0iTceeedSmRIFufzzz/Hddddp2KSDM+TTz6J7777TmVTSktLUVBQgOPHj9cprOXLl2PGjBkqK5Odna0er7CwEPn5+aqETTI8knWqjN27d6OoqMgmzNwdCh5CCGlCfL0tavZOak4RHdqaEcWldGkjpFHx8qq+rExOQviW6du4WvA4weWXXw5N05SokR6dtWvXqpIx4YEHHsCyZcvw8ssvq76ZwMBAXHXVVSgpKXH6eQ4fPow//OEPmDp1qiqRa9myJdatW4fbb78dxcXFSvDI41dFdfe5Izy3RAghTUyvVuFqLR7cPrKpQyGNBEvaCCGVERAQgCuuuEJldv7973+jS5cu6N+/v81AYPLkyZg4caIyG4iLi1PCpS5s3bpVZbVeeeUVDBkyBJ07d8bJk44ZsN69e2PFihWV/n2nTp2U6KnqfneDGR5CCGliZt3QDylZhWgfbR47bVI//tg3Ad3jgrHrl01NHQohxM2QsjbJvuzcuRM33nijg8j4+uuvVRbIy8sLjz/++DmObrWlY8eOKjM0a9Ys9Xgipt577z2HbcSUQISVmBlIb4+fn58yLZAyN+krevjhh5XJgdw+bNgwpKWlqZglS+RuMMNDCCFu4C5HsdO8aBURiPM7RCKh9qX9hJBmwv/93/+pErO9e/fihhtucLCRFmOD888/X4kUsYg2sj/O0qdPH/V4L774Inr27KkyStLPY49kfZYuXYrt27dj0KBBGDp0KBYuXKjc2gQRXPfffz+mT5+Obt264dprr0VqaircEWZ4CCGEEEIIcRPEoKBieZnhpLZy5UqH26QHRwwHDJwpcfvb3/6mLvbcdNNNDr9fdNFFKvtTVZyPPfaYurg7zPAQQgghhBBCPBYKHkIIIYQQQjwIKVELCQmp9NKjDjN7zA5L2gghhBBCCPEg/vjHP2Lw4MGV3ufr64vmBgUPIYQQQgghHkRoaKi6EB2WtBFCCCGEEI9EhngSc+LK/zsKHkIIIYQQ4lF4e3ur6+Li4qYOhdSR/Px8l5XgsaSNEEIIIYR4FDIrJigoSA3DlANmsVCuDhngKeKosLCwxm3dCU+MW9M0JXZkpk9ERIRNvNYHCh5CCCGEEOJReHl5IT4+HocOHcKRI0dq3F4OsgsKChAYGKj+1ix4ctwRERGIi4tzyfNR8BBCCCGEEI/Dz88PnTp1qlVZW0lJCdasWYPhw4ebysXMU+P29fV1SWbHgIKHEEIIIYR4JFIuFRAQUON2cnBdWlqqtjWTcGDctcM8xX6EEEIIIYQQ4iQUPIQQQgghhBCPhYKHEEIIIYQQ4rH4mGnwUHZ2dp0bo8TeTv7eTPWNZozbjDELjLtxMWPcZozZFXEb37sc3ncuzXFtMmPMAuNuXMwYtxljbs5xZzu5NplC8OTk5KjrxMTEpg6FEEKaJfI9HB4e3tRhuBVcmwghxBxrk5dmgtN2Mpzo5MmTCA0NrZPHuKhAWZCOHTuGsLAwmAUzxm3GmAXG3biYMW4zxuyKuGWJkAUlISHBVEPtGoPmuDaZMWaBcTcuZozbjDE357g1J9cmU2R45IW0bt263o8jO9RMbwYzx23GmAXG3biYMW4zxlzfuJnZqZzmvDaZMWaBcTcuZozbjDE317jDnVibeLqOEEIIIYQQ4rFQ8BBCCCGEEEI8lmYhePz9/fHEE0+oazNhxrjNGLPAuBsXM8ZtxpjNHHdzwIz/N2aMWWDcjYsZ4zZjzALjrh2mMC0ghBBCCCGEkLrQLDI8hBBCCCGEkOYJBQ8hhBBCCCHEY6HgIYQQQgghhHgsFDyEEEIIIYQQj8XjBc/bb7+Ntm3bIiAgAIMHD8bmzZsb9fnXrFmDyy+/XE2ClUncCxYscLhfPCOmT5+O+Ph4BAYGYtSoUfj9998dtklPT8ekSZPUYKaIiAjcfvvtyM3Nddjm119/xYUXXqhep0yunTlzZp1jnjFjBs477zw1PTwmJgYTJkzA3r17HbYpLCzEn//8Z0RGRiIkJARXXnklTp065bDN0aNHcdlllyEoKEg9zoMPPojS0lKHbVavXo3+/fsrl46OHTvi448/rnPc7777Lnr37m0bYjV06FB8//33bh1zRV544QX1Prn33nvdOu4nn3xSxWl/6dq1q1vHbHDixAnceOONKjb5zPXq1Qtbtmxx68+kfIdV3N9ykX3s7vubuN/aZMZ1yaxrkyesSwLXJq5Npl+XNA/myy+/1Pz8/LQPP/xQ27lzp3bnnXdqERER2qlTpxothkWLFmmPPfaY9vXXX4sbnjZ//nyH+1944QUtPDxcW7BggbZ9+3btj3/8o9auXTutoKDAts2ll16q9enTR9u4caO2du1arWPHjtr1119vuz8rK0uLjY3VJk2apP3222/av//9by0wMFD75z//WaeYx4wZo3300UfqsbZt26aNGzdOS0pK0nJzc23bTJkyRUtMTNRWrFihbdmyRRsyZIh2/vnn2+4vLS3VevbsqY0aNUr75Zdf1H6IiorSHnnkEds2Bw8e1IKCgrT77rtP27VrlzZr1izN29tbW7x4cZ3i/uabb7TvvvtO27dvn7Z3717t0Ucf1Xx9fdXrcNeY7dm8ebPWtm1brXfv3to999xju90d437iiSe0Hj16aMnJybZLWlqaW8cspKena23atNEmT56sbdq0ST3HkiVLtP3797v1ZzI1NdVhXy9btkx9n6xatcqt9zdxz7XJjOuSWdcms69LAtcmrk2esC55tOAZNGiQ9uc//9n2e1lZmZaQkKDNmDGjSeKpuLCUl5drcXFx2ksvvWS7LTMzU/P391dvQkH+g+XvfvrpJ9s233//vebl5aWdOHFC/f7OO+9oLVq00IqKimzbPPzww1qXLl1cEre8qSWGH374wRajfGH/5z//sW2ze/dutc2GDRvU7/LGtVgsWkpKim2bd999VwsLC7PF+dBDD6kvJnuuvfZatai5Ctkvc+bMcfuYc3JytE6dOqkvjIsuusi2qLhr3LKoyJdqZbhrzMbn4oILLqjyfrN8JuX90aFDBxWvO+9v4v5rk1nXJTOvTWZZlwSuTVybPGVd8tiStuLiYmzdulWl/AwsFov6fcOGDXAHDh06hJSUFIcYw8PDVXmDEaNcS1py4MCBtm1ke3ktmzZtsm0zfPhw+Pn52bYZM2aMSvVnZGTUO86srCx13bJlS3Ut+7WkpMQhbkkZJyUlOcQt6djY2FiHmLKzs7Fz507bNvaPYWzjiv+fsrIyfPnll8jLy1MlBO4es6R9Ja1b8bHdOW5JpUtJTPv27VUKXVLT7h7zN998oz5LV199tUqf9+vXD7NnzzbVZ1K+2z777DPcdtttqnzAnfc3Md/aZIbPgFnXJrOtSwLXJq5NnrIueazgOX36tPpysd+Rgvwubxp3wIijuhjlWt789vj4+KgvePttKnsM++eoK+Xl5apmd9iwYejZs6ftMeXDIh+s6uKuKaaqtpE3e0FBQZ3i3bFjh6oVlVrPKVOmYP78+ejevbtbxywL4M8//6zq0yvirnHLl6zU0S5evFjVqMuXsdQE5+TkuG3MwsGDB1W8nTp1wpIlSzB16lT89a9/xSeffGKaz6T0W2RmZmLy5Mm2x3PX/U3MtzaZ4TNgtrXJjOuSwLWpcWL2hLVpgQnWJZ86vC7SjJCzO7/99hvWrVsHM9ClSxds27ZNnfmbN28ebrnlFvzwww9wV44dO4Z77rkHy5YtUw2EZmHs2LG2n6UhVxaZNm3aYO7cuaqZ0l2RgyQ5+/X888+r3+Usmry/33vvPfVeMQMffPCB2v9yBpOQ5oqZ1iazrUsC16bGxexr0wcmWJc8NsMTFRUFb2/vcxwh5Pe4uDi4A0Yc1cUo16mpqQ73i4OFOHHYb1PZY9g/R12YNm0avv32W6xatQqtW7d2iFvSl6Lmq4u7ppiq2kbcRer6xSRnFMTFY8CAAeqsVJ8+ffDGG2+4bcyS9pX/X3EgkTMxcpGF8M0331Q/y5kMd4y7InIWp3Pnzti/f7/b7mtB3G3kzKo93bp1s5U8uPtn8siRI1i+fDnuuOMO223uvL+J+dYmd/8MmHFtMtu6JHBtatyYzbw2HTHJuuSxgke+YOTLZcWKFQ4KWn6X2ll3oF27duo/0z5GSdNJraURo1zLG0a+fAxWrlypXoucuTC2EZtRqZc0kLMyclapRYsWTsclfayyoEjaXZ5L4rRH9quvr69D3FL/KR9M+7gljW//4ZOY5E1qfKhlG/vHMLZx5f+P7KeioiK3jXnkyJHqOeXsn3GRszxSd2z87I5xV0RsLw8cOKC+tN11XwtS/lLRxnbfvn3qDKA7fyYNPvroI1WyIDX1Bu68v4n51iZ3/gx4ytrk7uuSwLWJa5PHrUuah1t/ioPFxx9/rNwr7rrrLmX9ae8I0dCIw4nY7clFdverr76qfj5y5IjNZlBiWrhwofbrr79q48ePr9RmsF+/fsqqcN26dcoxxd5mUNwwxGbwpptuUjaD8rrFxq+u9p9Tp05V1oerV692sBzMz8+3bSN2g2IHunLlSmU3OHToUHWpaDc4evRoZR8qFoLR0dGV2g0++OCDyr3j7bffrpe149///nfl1nPo0CG1L+V3cSdZunSp28ZcGfZOOO4a9/3336/eH7Kv169fr2wlxU5SXJPcNWbDXtXHx0d77rnntN9//137/PPP1XN89tlntm3c8TNpOHnJPhVHnYq46/4m7rk2mXFdMuva5CnrksC1qWFiNvPaVGaidcmjBY8gnt2yw2XmgViBijd5YyJ+5LKgVLzccsst6n6x73v88cfVG1AWwJEjRyqvfnvOnDmj3rAhISHKru/WW29VC5Y94skulobyGK1atVIfjLpSWbxykfkHBvIBu/vuu5W9obwZJ06cqBYeew4fPqyNHTtWebzLF458EZWUlJyzf/r27av+f9q3b+/wHM5y2223KR97eSz50Mi+NBYVd425NouKO8YttpDx8fHqseT9Jr/bzwtwx5gN/ve//6kvWfmsdO3aVXv//fcd7nfHz6QgMxnkc1gxFnff38T91iYzrktmXZs8ZV0SuDY1TMxmXpuWmGhd8pJ/nM8LEUIIIYQQQoj747E9PIQQQgghhBBCwUMIIYQQQgjxWCh4CCGEEEIIIR4LBQ8hhBBCCCHEY6HgIYQQQgghhHgsFDyEEEIIIYQQj4WChxBCCCGEEOKxUPAQQgghhBBCPBYKHkJcxOTJkzFhwoSmDoMQQghRcF0iRIeChxBCCCGEEOKxUPAQ4iTz5s1Dr169EBgYiMjISIwaNQoPPvggPvnkEyxcuBBeXl7qsnr1arX9sWPHcM011yAiIgItW7bE+PHjcfjw4XPOwD311FOIjo5GWFgYpkyZguLi4iZ8lYQQQswC1yVCqsenhvsJIXYkJyfj+uuvx8yZMzFx4kTk5ORg7dq1uPnmm3H06FFkZ2fjo48+UtvKIlJSUoIxY8Zg6NChajsfHx88++yzuPTSS/Hrr7/Cz89PbbtixQoEBASoxUgWnVtvvVUtWs8991wTv2JCCCHuDNclQmqGgocQJxeW0tJSXHHFFWjTpo26Tc6qCXJmraioCHFxcbbtP/vsM5SXl2POnDnq7JogC4+cVZNFZPTo0eo2WWA+/PBDBAUFoUePHnj66afV2blnnnkGFgsTsYQQQiqH6xIhNcN3LCFO0KdPH4wcOVItJldffTVmz56NjIyMKrffvn079u/fj9DQUISEhKiLnGErLCzEgQMHHB5XFhUDOfOWm5uryg4IIYSQquC6REjNMMNDiBN4e3tj2bJl+PHHH7F06VLMmjULjz32GDZt2lTp9rI4DBgwAJ9//vk590ldNCGEEFIfuC4RUjMUPIQ4iZQADBs2TF2mT5+uSgjmz5+v0v9lZWUO2/bv3x9fffUVYmJiVNNndWfcCgoKVPmBsHHjRnXWLTExscFfDyGEEHPDdYmQ6mFJGyFOIGfMnn/+eWzZskU1g3799ddIS0tDt27d0LZtW9XwuXfvXpw+fVo1hk6aNAlRUVHKAUeaQw8dOqRqpP/617/i+PHjtscV55vbb78du3btwqJFi/DEE09g2rRprJMmhBBSLVyXCKkZZngIcQI5G7ZmzRq8/vrryvlGzqK98sorGDt2LAYOHKgWDbmWkoFVq1ZhxIgRavuHH35YNZSKe06rVq1UvbX9mTX5vVOnThg+fLhqMBXHnSeffLJJXyshhBD3h+sSITXjpWmaVovtCCENhMw7yMzMxIIFC5o6FEIIIYTrEvE4mJckhBBCCCGEeCwUPIQQQgghhBCPhSVthBBCCCGEEI+FGR5CCCGEEEKIx0LBQwghhBBCCPFYKHgIIYQQQgghHgsFDyGEEEIIIcRjoeAhhBBCCCGEeCwUPIQQQgghhBCPhYKHEEIIIYQQ4rFQ8BBCCCGEEEI8FgoeQgghhBBCCDyV/wej07DteaJYvwAAAABJRU5ErkJggg=="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "33f560169d59414c"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
